diff --git a/.github/actions/setup_rust/action.yml b/.github/actions/setup_rust/action.yml
index bf3ef5c7fc..233ff6da98 100644
--- a/.github/actions/setup_rust/action.yml
+++ b/.github/actions/setup_rust/action.yml
@@ -15,3 +15,4 @@ runs:
       uses: dtolnay/rust-toolchain@master
       with:
         toolchain: ${{ steps.rust-version.outputs.version }}
+        components: cargo,clippy,rust-docs,rust-src,rust-std,rustc,rustfmt
diff --git a/.github/workflows/_release_docker.yml b/.github/workflows/_release_docker.yml
index eabea2205d..91d8f49492 100644
--- a/.github/workflows/_release_docker.yml
+++ b/.github/workflows/_release_docker.yml
@@ -38,9 +38,10 @@ jobs:
       - name: Print input
         run: echo '${{ toJSON(inputs) }}'
 
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
         with:
           ref: ${{ inputs.base }}
+          token: '${{ secrets.PULL_TOKEN }}'
 
       - name: Read rust version
         run: echo "RUST_VERSION=$(cargo metadata --no-deps --format-version 1 | jq -r '.packages[0].rust_version')" >> $GITHUB_ENV
@@ -71,17 +72,17 @@ jobs:
           tags: ${{ inputs.tag }}
 
       - name: Login to Docker Hub
-        uses: docker/login-action@v3
+        uses: docker/login-action@v4
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+        uses: docker/setup-buildx-action@v4
 
       - name: Build and push by digest
         id: build
-        uses: docker/build-push-action@v6
+        uses: docker/build-push-action@v7
         with:
           context: .
           build-args: |
@@ -114,20 +115,20 @@ jobs:
       - build
     steps:
       - name: Download digests
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v8
         with:
           path: /tmp/digests
           pattern: digests-${{ inputs.python }}-*
           merge-multiple: true
 
       - name: Login to Docker Hub
-        uses: docker/login-action@v3
+        uses: docker/login-action@v4
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+        uses: docker/setup-buildx-action@v4
 
       - name: Docker meta
         id: meta
diff --git a/.github/workflows/_release_github.yml b/.github/workflows/_release_github.yml
index 4483aa5e0f..f45528318b 100644
--- a/.github/workflows/_release_github.yml
+++ b/.github/workflows/_release_github.yml
@@ -24,7 +24,10 @@ jobs:
         include:
           - os: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v5
+        with:
+          submodules: recursive
+          token: '${{ secrets.PULL_TOKEN }}'
       - run: |
           git config --global user.email "ben.steer@pometry.com"
           git config --global user.name "Pometry-Team"
diff --git a/.github/workflows/_release_python.yml b/.github/workflows/_release_python.yml
index 0604eb058a..d0ffb60e66 100644
--- a/.github/workflows/_release_python.yml
+++ b/.github/workflows/_release_python.yml
@@ -41,8 +41,10 @@ jobs:
             ~/.cargo/git/db/
           key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
           restore-keys: ${{ runner.os }}-cargo-
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v5
         with:
+          submodules: recursive
+          token: '${{ secrets.PULL_TOKEN }}'
           ref: ${{ inputs.base }}
       - uses: actions/setup-python@v4
         with:
@@ -134,9 +136,11 @@ jobs:
         uses: arduino/setup-protoc@v3
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v5
         with:
           ref: ${{ inputs.base }}
+          submodules: recursive
+          token: '${{ secrets.PULL_TOKEN }}'
       - uses: actions/setup-python@v4
         with:
           python-version: |
@@ -179,9 +183,11 @@ jobs:
             ~/.cargo/git/db/
           key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
           restore-keys: ${{ runner.os }}-cargo-
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v5
         with:
           ref: ${{ inputs.base }}
+          submodules: recursive
+          token: '${{ secrets.PULL_TOKEN }}'
       - uses: actions/setup-python@v4
         with:
           python-version: |
@@ -207,7 +213,7 @@ jobs:
     name: Publish to PyPi
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/download-artifact@v4
+      - uses: actions/download-artifact@v8
         with:
           pattern: pyartifacts-*
           merge-multiple: true
@@ -225,7 +231,7 @@ jobs:
           skip_existing: true
           verify_metadata: false
       - name: Deleting artifacts
-        uses: geekyeggo/delete-artifact@v2
+        uses: geekyeggo/delete-artifact@v6
         with:
           failOnError: false
           name: |
diff --git a/.github/workflows/_release_rust.yml b/.github/workflows/_release_rust.yml
index 7e0ded59b8..376bb5a8e8 100644
--- a/.github/workflows/_release_rust.yml
+++ b/.github/workflows/_release_rust.yml
@@ -35,8 +35,10 @@ jobs:
         uses: arduino/setup-protoc@v3
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
         with:
+          submodules: recursive
+          token: '${{ secrets.PULL_TOKEN }}'
           ref: ${{ inputs.base }}
       - name: Setup rust
         uses: dtolnay/rust-toolchain@master
diff --git a/.github/workflows/bench-graphql.yml b/.github/workflows/bench-graphql.yml
index 78d2eeb88f..675525d9e3 100644
--- a/.github/workflows/bench-graphql.yml
+++ b/.github/workflows/bench-graphql.yml
@@ -14,8 +14,11 @@ jobs:
     name: GraphQL Benchmark
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v5
         name: Checkout
+        with:
+          submodules: recursive
+          token: '${{ secrets.PULL_TOKEN }}'
       - name: Install Protoc
         uses: arduino/setup-protoc@v3
         with:
@@ -31,7 +34,7 @@ jobs:
           make install-python clean
         #                     ↑ this is for freeing up space used by cargo before installing raphtory
       - name: Set up pnpm
-        uses: pnpm/action-setup@v4
+        uses: pnpm/action-setup@v5
         with:
           version: 9
       - uses: grafana/setup-k6-action@v1
@@ -39,8 +42,10 @@ jobs:
           k6-version: "1.0.0"
       - name: Run GraphQL benchmarks
         run: cd graphql-bench && make bench-local
-      - name: Restore metadata file
-        run: git restore graphql-bench/data/apache/master/.raph # otherwise github-action-benchmark fails to create the commit
+      - name: Restore modified files
+        run: |
+          git restore Cargo.lock # modified by build; github-action-benchmark can't switch to gh-pages with dirty working tree
+          git restore graphql-bench/data/apache/master # otherwise github-action-benchmark fails to create the commit
       - name: Print bench results
         run: cat graphql-bench/output.json
       - name: Store benchmark results from master branch
diff --git a/.github/workflows/benchmark.yml b/.github/workflows/benchmark.yml
index 01421a1dfa..fb8a561e63 100644
--- a/.github/workflows/benchmark.yml
+++ b/.github/workflows/benchmark.yml
@@ -26,8 +26,11 @@ jobs:
         include:
           - os: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v5
         name: Checkout
+        with:
+          submodules: recursive
+          token: '${{ secrets.PULL_TOKEN }}'
       - uses: ./.github/actions/setup_rust
         name: Setup Rust
       - name: Install Protoc
@@ -38,7 +41,7 @@ jobs:
         uses: Swatinem/rust-cache@v2
         with:
           cache-all-crates: true
-      - uses: webfactory/ssh-agent@v0.9.0
+      - uses: webfactory/ssh-agent@v0.10.0
         name: Load raphtory-disk_graph key
         with:
           ssh-private-key: ${{ secrets.RA_SSH_PRIVATE_KEY }}
@@ -46,8 +49,8 @@ jobs:
         run: |
           set -o pipefail
           cargo bench --bench base --bench algobench -p raphtory-benchmark -- --output-format=bencher | tee benchmark-result.txt
-      - name: Delete cargo.lock if it exists
-        run: rm -f Cargo.lock
+      - name: Restore Cargo.lock to avoid dirty working tree
+        run: git checkout -- Cargo.lock
       - name: Store benchmark results from master branch
         if: github.ref == 'refs/heads/master'
         uses: benchmark-action/github-action-benchmark@v1
diff --git a/.github/workflows/code_coverage.yml b/.github/workflows/code_coverage.yml
index 7db020c751..6eb89401c8 100644
--- a/.github/workflows/code_coverage.yml
+++ b/.github/workflows/code_coverage.yml
@@ -18,8 +18,12 @@
        SCCACHE_DIR: /home/runner/.cache/sccache
        SCCACHE_PATH: /home/runner/.cache/sccache
      steps:
-       - uses: actions/checkout@v3
+       - uses: actions/checkout@v5
          name: Checkout
+         with:
+           ref: ${{ github.head_ref }}
+           submodules: recursive
+           token: '${{ secrets.PULL_TOKEN }}'
        - name: Cache sccache
          uses: actions/cache@v3
          with:
diff --git a/.github/workflows/format.yml b/.github/workflows/format.yml
index 8e711ca6aa..dc27e2bc49 100644
--- a/.github/workflows/format.yml
+++ b/.github/workflows/format.yml
@@ -8,10 +8,13 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
         name: Checkout
         with:
           ref: ${{ github.head_ref }}
+          submodules: recursive
+          token: '${{ secrets.PULL_TOKEN }}'
+          persist-credentials: 'false'
       - uses: ./.github/actions/setup_rust
         name: Setup Rust
       - name: Setup nightly rust
@@ -34,7 +37,7 @@ jobs:
         run: |
           python -m pip install black mypy pandas-stubs
       - name: Setup Node.js
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v6
         with:
           node-version: '20'
       - name: Install raphtory
@@ -76,10 +79,9 @@ jobs:
             echo "Changes detected. Committing and pushing..."
             git config user.name "github-actions[bot]"
             git config user.email "github-actions[bot]@users.noreply.github.com"
-            git checkout ${{ github.head_ref }}
             git add .
             git commit -m "chore: apply tidy-public auto-fixes"
-            git push --force-with-lease origin HEAD:${{ github.head_ref }} 
+            git push https://oauth2:$GITHUB_TOKEN@github.com/Pometry/Raphtory.git HEAD:${{ github.head_ref }} 
           else
             echo "No changes to commit."
           fi
\ No newline at end of file
diff --git a/.github/workflows/manual_release_docker_cloud.yml b/.github/workflows/manual_release_docker_cloud.yml
index fd9fe972fc..3cdfd2217f 100644
--- a/.github/workflows/manual_release_docker_cloud.yml
+++ b/.github/workflows/manual_release_docker_cloud.yml
@@ -19,8 +19,10 @@ jobs:
   docker:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
         with:
+          submodules: recursive
+          token: '${{ secrets.PULL_TOKEN }}'
           ref: ${{ inputs.base }}
 
       - name: Read rust version
@@ -35,20 +37,20 @@ jobs:
           fi
 
       - name: Login to Docker Hub
-        uses: docker/login-action@v3
+        uses: docker/login-action@v4
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+        uses: docker/setup-buildx-action@v4
         with:
           driver: cloud
           endpoint: "pometry/raphtory"
           install: true
 
       - name: Build and push
-        uses: docker/build-push-action@v6
+        uses: docker/build-push-action@v7
         with:
           context: .
           build-args: RUST_VERSION=${{ env.RUST_VERSION }}
diff --git a/.github/workflows/manual_retag_docker.yml b/.github/workflows/manual_retag_docker.yml
index f4ea0fb997..ff34919727 100644
--- a/.github/workflows/manual_retag_docker.yml
+++ b/.github/workflows/manual_retag_docker.yml
@@ -21,13 +21,13 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Login to Docker Hub
-        uses: docker/login-action@v3
+        uses: docker/login-action@v4
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+        uses: docker/setup-buildx-action@v4
 
       - name: Retag multi-platform image
         run: |
diff --git a/.github/workflows/nightly_release.yml b/.github/workflows/nightly_release.yml
index ecccb14694..26772113f7 100644
--- a/.github/workflows/nightly_release.yml
+++ b/.github/workflows/nightly_release.yml
@@ -15,7 +15,10 @@ jobs:
     outputs:
       should_run: ${{ steps.should_run.outputs.should_run }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
+        with:
+          submodules: recursive
+          token: '${{ secrets.PULL_TOKEN }}'
       - id: should_run
         continue-on-error: true
         name: Check latest commit is less than a day
diff --git a/.github/workflows/release_auto.yml b/.github/workflows/release_auto.yml
index 9b4fcb52cd..e1d36ec27e 100644
--- a/.github/workflows/release_auto.yml
+++ b/.github/workflows/release_auto.yml
@@ -26,9 +26,10 @@ jobs:
     outputs:
       version: ${{ steps.version.outputs.version }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
         with:
           ref: ${{ inputs.base }}
+          token: '${{ secrets.PULL_TOKEN }}'
       - id: version
         run: echo "version=$(make print-version)" >> $GITHUB_OUTPUT
   call-release-rust-workflow:
diff --git a/.github/workflows/release_bump_versions.yml b/.github/workflows/release_bump_versions.yml
index 7f6d5c1056..0de369dda9 100644
--- a/.github/workflows/release_bump_versions.yml
+++ b/.github/workflows/release_bump_versions.yml
@@ -46,7 +46,10 @@ jobs:
             ~/.cargo/git/db/
           key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
           restore-keys: ${{ runner.os }}-cargo-
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v5
+        with:
+          submodules: recursive
+          token: '${{ secrets.PULL_TOKEN }}'
       - run: |
           git config --global user.email "ben.steer@pometry.com"
           git config --global user.name "Pometry-Team"
@@ -70,7 +73,7 @@ jobs:
           echo CRATE_VERSION=$(cat Cargo.toml | grep version | head -n1 | cut -d '"' -f2) >> $GITHUB_ENV
           echo "Crate version is $CRATE_VERSION"
       - name: "Make a PR to bump version"
-        uses: peter-evans/create-pull-request@v5
+        uses: peter-evans/create-pull-request@v8
         with:
           base: ${{ inputs.base }}
           author: ${{ github.actor }} <${{ github.actor }}@users.noreply.github.com>
diff --git a/.github/workflows/rust_format_check.yml b/.github/workflows/rust_format_check.yml
index 150fbd314b..9d60a342a1 100644
--- a/.github/workflows/rust_format_check.yml
+++ b/.github/workflows/rust_format_check.yml
@@ -15,7 +15,10 @@ jobs:
   rust-format-check:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
+        with:
+          submodules: recursive
+          token: '${{ secrets.PULL_TOKEN }}'
       - name: Setup nightly rust
         run: |
           rustup toolchain install nightly --allow-downgrade -c rustfmt
diff --git a/.github/workflows/stress-test.yml b/.github/workflows/stress-test.yml
index 9878f3fce6..6ffa7b25eb 100644
--- a/.github/workflows/stress-test.yml
+++ b/.github/workflows/stress-test.yml
@@ -11,8 +11,11 @@ jobs:
     name: GraphQL Stress Test
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v5
         name: Checkout
+        with:
+          submodules: recursive
+          token: '${{ secrets.PULL_TOKEN }}'
       - name: Install Protoc
         uses: arduino/setup-protoc@v3
         with:
@@ -21,23 +24,22 @@ jobs:
         uses: Swatinem/rust-cache@v2
         with:
           cache-all-crates: true
-      - name: Install maturin
-        run: pip install maturin==1.8.3
-      - name: Build raphtory
-        run: |
-          make install-python clean
-        #                     ↑ this is for freeing up space used by cargo before installing raphtory
+      - uses: ./.github/actions/setup_rust
+        name: Setup Rust
       - name: Set up pnpm
-        uses: pnpm/action-setup@v4
+        uses: pnpm/action-setup@v5
         with:
           version: 9
       - uses: grafana/setup-k6-action@v1
         with:
           k6-version: "1.0.0"
       - name: Run stress test
+        env:
+          RUST_BACKTRACE: 1
         run: |
+          cargo build --package raphtory-server --bin raphtory-server --profile=build-fast
+          ./target/build-fast/raphtory-server server --work-dir graphs &
           cd graphql-bench
-          raphtory server &
           make stress-test
       - name: Upload k6 report
         if: always()
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 9b25a61435..1d3f3741be 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -17,22 +17,12 @@ jobs:
     name: Run Rust tests
     uses: ./.github/workflows/test_rust_workflow.yml
     secrets: inherit
-  call-test-rust-storage-workflow-in-local-repo:
-    name: Run Rust storage tests
-    uses: ./.github/workflows/test_rust_disk_storage_workflow.yml
-    secrets: inherit
   call-test-python-workflow-in-local-repo:
     name: Run Python tests
     uses: ./.github/workflows/test_python_workflow.yml
     with:
       test_python_lower: true
     secrets: inherit
-  call-test-python-disk-storage-workflow-in-local-repo:
-    name: Run Python storage tests
-    uses: ./.github/workflows/test_python_disk_storage_workflow.yml
-    with:
-      test_python_lower: true
-    secrets: inherit
   call-test-ui:
     name: Run UI Tests
     uses: ./.github/workflows/test_ui.yml
diff --git a/.github/workflows/test_during_pr.yml b/.github/workflows/test_during_pr.yml
index eaaa3874ab..8f5d4dc419 100644
--- a/.github/workflows/test_during_pr.yml
+++ b/.github/workflows/test_during_pr.yml
@@ -3,7 +3,8 @@ on:
   pull_request:
     branches:
       - master
-      - "0.16"
+      - db_v4
+      - v16
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
@@ -14,22 +15,12 @@ jobs:
     name: Run Rust tests
     uses: ./.github/workflows/test_rust_workflow.yml
     secrets: inherit
-  call-test-rust-storage-workflow-in-local-repo:
-    name: Run Rust storage tests
-    uses: ./.github/workflows/test_rust_disk_storage_workflow.yml
-    secrets: inherit
   call-test-python-workflow-in-local-repo:
     name: Run Python tests
     uses: ./.github/workflows/test_python_workflow.yml
     with:
       test_python_lower: false
     secrets: inherit
-  call-test-python-disk-storage-workflow-in-local-repo:
-    name: Run Python storage tests
-    uses: ./.github/workflows/test_python_disk_storage_workflow.yml
-    with:
-      test_python_lower: false
-    secrets: inherit
   call-test-ui-in-local-repo:
     name: Run UI Tests
     uses: ./.github/workflows/test_ui.yml
@@ -54,10 +45,8 @@ jobs:
     secrets: inherit
     needs: [
       call-test-rust-workflow-in-local-repo,
-      call-test-rust-storage-workflow-in-local-repo,
       call-test-python-workflow-in-local-repo,
-      call-test-python-disk-storage-workflow-in-local-repo,
-      call-test-ui-in-local-repo,
+      #      call-test-ui-in-local-repo,
       call-benchmark-workflow-in-local-repo,
       call-graphql-bench-workflow-in-local-repo,
       call-stress-test-workflow-in-local-repo
diff --git a/.github/workflows/test_python_disk_storage_workflow.yml b/.github/workflows/test_python_disk_storage_workflow.yml
deleted file mode 100644
index 8983052f86..0000000000
--- a/.github/workflows/test_python_disk_storage_workflow.yml
+++ /dev/null
@@ -1,67 +0,0 @@
-name: Run Python storage test
-permissions: { }
-on:
-  workflow_call:
-    inputs:
-      skip_tests:
-        type: boolean
-        default: false
-        required: false
-      test_python_lower:
-        type: boolean
-        default: false
-        required: false
-# DO NOT CHANGE NAME OF WORKFLOW, USED IN OTHER WORKFLOWS KEEP "Rust Tests"
-jobs:
-  select-strategy:
-    runs-on: ubuntu-latest
-    outputs:
-      python-versions: ${{ steps.set-matrix.outputs.python-versions }}
-    steps:
-      - id: set-matrix
-        run: |
-          echo "python-versions=[\"3.11\",\"3.14.0\"]" >> $GITHUB_OUTPUT
-  python-test:
-    if: ${{ !inputs.skip_tests }}
-    name: Python Tests
-    needs: select-strategy
-    strategy:
-      matrix:
-        python: ${{ fromJson(needs.select-strategy.outputs.python-versions) }}
-        os: [ macos-latest, ubuntu-latest, windows-latest ]
-    runs-on: '${{ matrix.os }}'
-    steps:
-      - uses: actions/checkout@v3
-        name: Checkout
-      - uses: maxim-lobanov/setup-xcode@v1
-        name: Xcode version
-        if: "contains(matrix.os, 'macOS')"
-        with:
-          xcode-version: latest-stable
-      - uses: ./.github/actions/setup_rust
-        name: Setup Rust
-      - name: Install Protoc
-        uses: arduino/setup-protoc@v3
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-      - uses: webfactory/ssh-agent@v0.7.0
-        name: Load raphtory-disk_graph key
-        with:
-          ssh-private-key: ${{ secrets.RA_SSH_PRIVATE_KEY }}
-      - uses: Swatinem/rust-cache@v2
-        name: Cargo cache
-        with:
-          cache-all-crates: true
-      - name: Setup Python ${{ matrix.python }}
-        uses: actions/setup-python@v4
-        with:
-          python-version: ${{ matrix.python }}
-          cache: 'pip'
-      - name: Activate pometry-storage in Cargo.toml
-        run: make pull-storage
-      - name: Install Python dependencies
-        run: |
-          python -m pip install tox
-      - name: Run Python tests
-        run: |
-          cd python && tox run -e storage
diff --git a/.github/workflows/test_python_workflow.yml b/.github/workflows/test_python_workflow.yml
index 102547627d..df333f4043 100644
--- a/.github/workflows/test_python_workflow.yml
+++ b/.github/workflows/test_python_workflow.yml
@@ -32,9 +32,11 @@ jobs:
         os: [ macos-latest, ubuntu-latest, windows-latest ]
     runs-on: '${{ matrix.os }}'
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
         name: Checkout
         with:
+          submodules: recursive
+          token: '${{ secrets.PULL_TOKEN }}'
           ref: ${{ github.head_ref }}
       - uses: maxim-lobanov/setup-xcode@v1
         name: Xcode version
diff --git a/.github/workflows/test_rust_disk_storage_workflow.yml b/.github/workflows/test_rust_disk_storage_workflow.yml
deleted file mode 100644
index d8d0bafad9..0000000000
--- a/.github/workflows/test_rust_disk_storage_workflow.yml
+++ /dev/null
@@ -1,82 +0,0 @@
-name: Run Rust test
-permissions: { }
-on:
-  workflow_call:
-    inputs:
-      skip_tests:
-        type: boolean
-        default: false
-        required: false
-# DO NOT CHANGE NAME OF WORKFLOW, USED IN OTHER WORKFLOWS KEEP "Rust Tests"
-jobs:
-  rust-test:
-    if: ${{ !inputs.skip_tests }}
-    name: Rust Tests
-    runs-on: '${{ matrix.os }}'
-    env:
-      RUST_BACKTRACE: 1
-    strategy:
-      matrix:
-        include:
-          - { os: macos-latest, flags: "" }
-          - { os: ubuntu-latest, flags: "-C link-arg=-fuse-ld=lld" }
-          - { os: windows-latest, flags: "" }
-    steps:
-      - uses: maxim-lobanov/setup-xcode@v1
-        name: Xcode version
-        if: "contains(matrix.os, 'macOS')"
-        with:
-          xcode-version: latest-stable
-      - uses: actions/checkout@v3
-        name: Checkout
-      - uses: ./.github/actions/setup_rust
-        name: Setup Rust
-      - name: Free up space (ubuntu)
-        if: "contains(matrix.os, 'ubuntu')"
-        run: |
-          sudo rm -rf /usr/share/dotnet
-          sudo rm -rf /usr/local/lib/android
-          sudo rm -rf /opt/ghc
-          sudo rm -rf "$AGENT_TOOLSDIRECTORY"
-      - name: Install LLD
-        if: "contains(matrix.os, 'ubuntu')"
-        run: |
-          sudo apt-get install lld
-      - uses: webfactory/ssh-agent@v0.7.0
-        name: Load pometry-storage key
-        with:
-          ssh-private-key: ${{ secrets.RA_SSH_PRIVATE_KEY }}
-      - name: Rust version
-        run: rustc --version --verbose
-      - uses: Swatinem/rust-cache@v2
-        name: Cargo cache
-        with:
-          cache-all-crates: true
-      - name: Install Protoc
-        uses: arduino/setup-protoc@v3
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-      - name: Install nextest
-        uses: taiki-e/install-action@v2
-        with:
-          tool: nextest@0.9.99
-      - name: Install cargo-hack
-        uses: taiki-e/install-action@cargo-hack
-      - name: Activate pometry-storage in Cargo.toml
-        run: make pull-storage
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.12'
-      - name: Run all Tests (disk_graph)
-        env:
-          RUSTFLAGS: -Awarnings ${{ matrix.flags }}
-          TEMPDIR: ${{ runner.temp }}
-        run: |
-          cargo nextest run --all --no-default-features --features "storage" --cargo-profile build-fast
-      - name: Check all features
-        env:
-          RUSTFLAGS: -Awarnings
-        run: |
-          cargo hack check --workspace --all-targets --each-feature  --skip extension-module,default
-
-
diff --git a/.github/workflows/test_rust_workflow.yml b/.github/workflows/test_rust_workflow.yml
index 87a4b9cefd..0caa121552 100644
--- a/.github/workflows/test_rust_workflow.yml
+++ b/.github/workflows/test_rust_workflow.yml
@@ -1,5 +1,5 @@
 name: Run Rust test
-permissions: {}
+permissions: { }
 on:
   workflow_call:
     inputs:
@@ -23,13 +23,10 @@ jobs:
           - os: ubuntu-latest
           - os: windows-latest
     steps:
-      - uses: maxim-lobanov/setup-xcode@v1
-        name: Xcode version
-        if: "contains(matrix.os, 'macOS')"
+      - uses: actions/checkout@v5
         with:
-          xcode-version: latest-stable
-      - uses: actions/checkout@v3
-        name: Checkout
+          submodules: recursive
+          token: '${{ secrets.PULL_TOKEN }}'
       - uses: ./.github/actions/setup_rust
         name: Setup Rust
       - name: Free up space (ubuntu)
@@ -50,9 +47,9 @@ jobs:
         with:
           cache-all-crates: true
       - name: Install nextest
-        uses: taiki-e/install-action@v2
-        with:
-          tool: nextest@0.9.99
+        uses: taiki-e/install-action@nextest
+      - name: Install cargo-hack
+        uses: taiki-e/install-action@cargo-hack
       - uses: actions/setup-python@v5
         with:
           python-version: "3.12"
@@ -61,7 +58,12 @@ jobs:
           RUSTFLAGS: -Awarnings
           TEMPDIR: ${{ runner.temp }}
         run: |
-          cargo nextest run --all --no-default-features --cargo-profile build-fast
+          cargo nextest run --workspace --no-default-features --cargo-profile build-fast
+      - name: Check all features
+        env:
+          RUSTFLAGS: -Awarnings
+        run: |
+          cargo hack check --workspace --all-targets --each-feature  --skip extension-module,default
   doc-test:
     if: ${{ !inputs.skip_tests }}
     name: "Doc tests"
@@ -72,7 +74,10 @@ jobs:
           - os: ubuntu-latest
     steps:
       - name: Checkout code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v5
+        with:
+          submodules: recursive
+          token: '${{ secrets.PULL_TOKEN }}'
       - uses: ./.github/actions/setup_rust
         name: Setup Rust
       - name: Install Protoc
diff --git a/.github/workflows/test_ui.yml b/.github/workflows/test_ui.yml
index ebe27b7e0b..54c7247bc0 100644
--- a/.github/workflows/test_ui.yml
+++ b/.github/workflows/test_ui.yml
@@ -18,23 +18,25 @@ jobs:
     strategy:
       matrix:
         python: ${{ fromJson(needs.select-strategy.outputs.python-versions) }}
-        os: [ ubuntu-latest ]
-    runs-on: '${{ matrix.os }}'
+        os: [ubuntu-latest]
+    runs-on: "${{ matrix.os }}"
     steps:
       - uses: actions/checkout@v5
         name: Checkout
         with:
           ref: ${{ github.head_ref }}
+          submodules: recursive
+          token: "${{ secrets.PULL_TOKEN }}"
       - uses: ./.github/actions/setup_rust
         name: Setup Rust
-      - name: Setup SSH for UI tests submodule
+      - name: Setup SSH for UI tests
         run: |
-          mkdir -p ~/.ssh                                                       
-          echo "${{ secrets.UI_TESTS_SSH_KEY }}" > ~/.ssh/id_ed25519            
-          chmod 600 ~/.ssh/id_ed25519                                           
+          mkdir -p ~/.ssh
+          echo "${{ secrets.UI_TESTS_SSH_KEY }}" > ~/.ssh/id_ed25519
+          chmod 600 ~/.ssh/id_ed25519
           ssh-keyscan github.com >> ~/.ssh/known_hosts
-      - name: Init and update UI tests submodule
-        run: make pull-ui-tests
+      - name: Update UI tests
+        run: make update-ui-tests
       - name: Install Protoc
         uses: arduino/setup-protoc@v3
         with:
@@ -49,13 +51,13 @@ jobs:
         uses: actions/setup-python@v4
         with:
           python-version: ${{ matrix.python }}
-          cache: 'pip'
+          cache: "pip"
       - name: Create python venv for Maturin
         run: python -m venv .venv
       - name: Setup Node.js
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v6
         with:
-          node-version: '20'
+          node-version: "20"
       - name: Build raphtory-python
         uses: PyO3/maturin-action@v1
         with:
@@ -80,4 +82,3 @@ jobs:
           name: playwright-report-with-py-${{ matrix.python }}
           path: ui-tests/playwright-report
           retention-days: 7
-
diff --git a/.gitignore b/.gitignore
index 0a0a442ff0..afd90f8332 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,6 +4,7 @@ massif.*
 .zed/
 .fleet/
 **/proptest-regressions/
+**/*.proptest-regressions
 # these are generated by flamegraph
 *.svg
 # this is for raphtory
diff --git a/.gitmodules b/.gitmodules
index 83994a118e..0b8628a385 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,6 +1,6 @@
-[submodule "pometry-storage-private"]
-	path = pometry-storage-private
-	url = git@github.com:Pometry/pometry-storage.git
-[submodule "ui-tests"]
-	path = ui-tests
-	url = git@github.com:Pometry/ui-tests.git
+[submodule "optd"]
+        path = optd
+	url = git@github.com:Pometry/optd.git
+[submodule "clam-core"]
+        path = clam-core
+	url = git@github.com:Pometry/optd-graph.git
diff --git a/Cargo.lock b/Cargo.lock
index 374836bda5..73b3a06f36 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1,6 +1,6 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 3
+version = 4
 
 [[package]]
 name = "Inflector"
@@ -26,7 +26,7 @@ checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0"
 dependencies = [
  "cfg-if",
  "cipher",
- "cpufeatures",
+ "cpufeatures 0.2.17",
 ]
 
 [[package]]
@@ -97,9 +97,9 @@ checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
 
 [[package]]
 name = "anstream"
-version = "0.6.21"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43d5b281e737544384e969a5ccad3f1cdd24b48086a0fc1b2a5262a26b8f4f4a"
+checksum = "824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d"
 dependencies = [
  "anstyle",
  "anstyle-parse",
@@ -112,15 +112,15 @@ dependencies = [
 
 [[package]]
 name = "anstyle"
-version = "1.0.13"
+version = "1.0.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5192cca8006f1fd4f7237516f40fa183bb07f8fbdfedaa0036de5ea9b0b45e78"
+checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000"
 
 [[package]]
 name = "anstyle-parse"
-version = "0.2.7"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e7644824f0aa2c7b9384579234ef10eb7efb6a0deb83f9630a49594dd9c15c2"
+checksum = "52ce7f38b242319f7cabaa6813055467063ecdc9d355bbb4ce0c68908cd8130e"
 dependencies = [
  "utf8parse",
 ]
@@ -147,18 +147,9 @@ dependencies = [
 
 [[package]]
 name = "anyhow"
-version = "1.0.100"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a23eb6b1614318a8071c9b2521f36b424b2c83db5eb3a0fead4a6c0809af6e61"
-
-[[package]]
-name = "ar_archive_writer"
-version = "0.2.0"
+version = "1.0.102"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0c269894b6fe5e9d7ada0cf69b5bf847ff35bc25fc271f08e1d080fce80339a"
-dependencies = [
- "object",
-]
+checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
 
 [[package]]
 name = "arbitrary"
@@ -171,9 +162,9 @@ dependencies = [
 
 [[package]]
 name = "arc-swap"
-version = "1.8.0"
+version = "1.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "51d03449bb8ca2cc2ef70869af31463d1ae5ccc8fa3e334b307203fbf815207e"
+checksum = "6a3a1fd6f75306b68087b831f025c712524bcb19aad54e557b1129cfa0a2b207"
 dependencies = [
  "rustversion",
 ]
@@ -198,9 +189,9 @@ checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
 
 [[package]]
 name = "arrow"
-version = "56.2.0"
+version = "57.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e833808ff2d94ed40d9379848a950d995043c7fb3e81a30b383f4c6033821cc"
+checksum = "e4754a624e5ae42081f464514be454b39711daae0458906dacde5f4c632f33a8"
 dependencies = [
  "arrow-arith",
  "arrow-array",
@@ -219,23 +210,23 @@ dependencies = [
 
 [[package]]
 name = "arrow-arith"
-version = "56.2.0"
+version = "57.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad08897b81588f60ba983e3ca39bda2b179bdd84dced378e7df81a5313802ef8"
+checksum = "f7b3141e0ec5145a22d8694ea8b6d6f69305971c4fa1c1a13ef0195aef2d678b"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
  "arrow-data",
  "arrow-schema",
  "chrono",
- "num",
+ "num-traits",
 ]
 
 [[package]]
 name = "arrow-array"
-version = "56.2.0"
+version = "57.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8548ca7c070d8db9ce7aa43f37393e4bfcf3f2d3681df278490772fd1673d08d"
+checksum = "4c8955af33b25f3b175ee10af580577280b4bd01f7e823d94c7cdef7cf8c9aef"
 dependencies = [
  "ahash",
  "arrow-buffer",
@@ -245,29 +236,33 @@ dependencies = [
  "chrono-tz 0.10.4",
  "half",
  "hashbrown 0.16.1",
- "num",
+ "num-complex",
+ "num-integer",
+ "num-traits",
 ]
 
 [[package]]
 name = "arrow-buffer"
-version = "56.2.0"
+version = "57.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e003216336f70446457e280807a73899dd822feaf02087d31febca1363e2fccc"
+checksum = "c697ddca96183182f35b3a18e50b9110b11e916d7b7799cbfd4d34662f2c56c2"
 dependencies = [
  "bytes",
  "half",
- "num",
+ "num-bigint",
+ "num-traits",
 ]
 
 [[package]]
 name = "arrow-cast"
-version = "56.2.0"
+version = "57.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "919418a0681298d3a77d1a315f625916cb5678ad0d74b9c60108eb15fd083023"
+checksum = "646bbb821e86fd57189c10b4fcdaa941deaf4181924917b0daa92735baa6ada5"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
  "arrow-data",
+ "arrow-ord",
  "arrow-schema",
  "arrow-select",
  "atoi",
@@ -276,15 +271,15 @@ dependencies = [
  "comfy-table",
  "half",
  "lexical-core",
- "num",
+ "num-traits",
  "ryu",
 ]
 
 [[package]]
 name = "arrow-csv"
-version = "56.2.0"
+version = "57.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfa9bf02705b5cf762b6f764c65f04ae9082c7cfc4e96e0c33548ee3f67012eb"
+checksum = "8da746f4180004e3ce7b83c977daf6394d768332349d3d913998b10a120b790a"
 dependencies = [
  "arrow-array",
  "arrow-cast",
@@ -297,21 +292,22 @@ dependencies = [
 
 [[package]]
 name = "arrow-data"
-version = "56.2.0"
+version = "57.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5c64fff1d142f833d78897a772f2e5b55b36cb3e6320376f0961ab0db7bd6d0"
+checksum = "1fdd994a9d28e6365aa78e15da3f3950c0fdcea6b963a12fa1c391afb637b304"
 dependencies = [
  "arrow-buffer",
  "arrow-schema",
  "half",
- "num",
+ "num-integer",
+ "num-traits",
 ]
 
 [[package]]
 name = "arrow-ipc"
-version = "56.2.0"
+version = "57.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d3594dcddccc7f20fd069bc8e9828ce37220372680ff638c5e00dea427d88f5"
+checksum = "abf7df950701ab528bf7c0cf7eeadc0445d03ef5d6ffc151eaae6b38a58feff1"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -319,15 +315,15 @@ dependencies = [
  "arrow-schema",
  "arrow-select",
  "flatbuffers",
- "lz4_flex",
+ "lz4_flex 0.12.1",
  "zstd",
 ]
 
 [[package]]
 name = "arrow-json"
-version = "56.2.0"
+version = "57.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88cf36502b64a127dc659e3b305f1d993a544eab0d48cce704424e62074dc04b"
+checksum = "0ff8357658bedc49792b13e2e862b80df908171275f8e6e075c460da5ee4bf86"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -336,20 +332,22 @@ dependencies = [
  "arrow-schema",
  "chrono",
  "half",
- "indexmap 2.13.0",
+ "indexmap 2.14.0",
+ "itoa",
  "lexical-core",
  "memchr",
- "num",
- "serde",
+ "num-traits",
+ "ryu",
+ "serde_core",
  "serde_json",
  "simdutf8",
 ]
 
 [[package]]
 name = "arrow-ord"
-version = "56.2.0"
+version = "57.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c8f82583eb4f8d84d4ee55fd1cb306720cddead7596edce95b50ee418edf66f"
+checksum = "f7d8f1870e03d4cbed632959498bcc84083b5a24bded52905ae1695bd29da45b"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -360,9 +358,9 @@ dependencies = [
 
 [[package]]
 name = "arrow-row"
-version = "56.2.0"
+version = "57.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d07ba24522229d9085031df6b94605e0f4b26e099fb7cdeec37abd941a73753"
+checksum = "18228633bad92bff92a95746bbeb16e5fc318e8382b75619dec26db79e4de4c0"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -373,34 +371,34 @@ dependencies = [
 
 [[package]]
 name = "arrow-schema"
-version = "56.2.0"
+version = "57.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b3aa9e59c611ebc291c28582077ef25c97f1975383f1479b12f3b9ffee2ffabe"
+checksum = "8c872d36b7bf2a6a6a2b40de9156265f0242910791db366a2c17476ba8330d68"
 dependencies = [
  "bitflags",
- "serde",
+ "serde_core",
  "serde_json",
 ]
 
 [[package]]
 name = "arrow-select"
-version = "56.2.0"
+version = "57.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c41dbbd1e97bfcaee4fcb30e29105fb2c75e4d82ae4de70b792a5d3f66b2e7a"
+checksum = "68bf3e3efbd1278f770d67e5dc410257300b161b93baedb3aae836144edcaf4b"
 dependencies = [
  "ahash",
  "arrow-array",
  "arrow-buffer",
  "arrow-data",
  "arrow-schema",
- "num",
+ "num-traits",
 ]
 
 [[package]]
 name = "arrow-string"
-version = "56.2.0"
+version = "57.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53f5183c150fbc619eede22b861ea7c0eebed8eaac0333eaa7f6da5205fd504d"
+checksum = "85e968097061b3c0e9fe3079cf2e703e487890700546b5b0647f60fca1b5a8d8"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -408,7 +406,7 @@ dependencies = [
  "arrow-schema",
  "arrow-select",
  "memchr",
- "num",
+ "num-traits",
  "regex",
  "regex-syntax",
 ]
@@ -433,20 +431,14 @@ dependencies = [
 
 [[package]]
 name = "async-compression"
-version = "0.4.19"
+version = "0.4.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06575e6a9673580f52661c92107baabffbf41e2141373441cbcdc47cb733003c"
+checksum = "d0f9ee0f6e02ffd7ad5816e9464499fba7b3effd01123b515c41d1697c43dad1"
 dependencies = [
- "brotli 7.0.0",
- "bzip2 0.5.2",
- "flate2",
- "futures-core",
- "memchr",
+ "compression-codecs",
+ "compression-core",
  "pin-project-lite",
  "tokio",
- "xz2",
- "zstd",
- "zstd-safe",
 ]
 
 [[package]]
@@ -468,8 +460,8 @@ dependencies = [
  "fnv",
  "futures-util",
  "handlebars",
- "http 1.4.0",
- "indexmap 2.13.0",
+ "http",
+ "indexmap 2.14.0",
  "mime",
  "multer",
  "num-traits",
@@ -480,7 +472,7 @@ dependencies = [
  "serde_urlencoded",
  "static_assertions_next",
  "tempfile",
- "thiserror 2.0.17",
+ "thiserror 2.0.18",
 ]
 
 [[package]]
@@ -496,8 +488,8 @@ dependencies = [
  "proc-macro2",
  "quote",
  "strum 0.27.2",
- "syn 2.0.114",
- "thiserror 2.0.17",
+ "syn 2.0.117",
+ "thiserror 2.0.18",
 ]
 
 [[package]]
@@ -514,13 +506,13 @@ dependencies = [
 
 [[package]]
 name = "async-graphql-poem"
-version = "7.1.0"
+version = "7.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ff5480bfb998f5405f4ad3d861b69a0467e8667f9f4174e86e85bf896c1f8c9"
+checksum = "5484e75de31fd28a2827010e5170b61a37bdb472467b3ba9efc5535c192da664"
 dependencies = [
  "async-graphql",
  "futures-util",
- "http 1.4.0",
+ "http",
  "mime",
  "poem",
  "serde_json",
@@ -536,7 +528,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3e3ef112905abea9dea592fc868a6873b10ebd3f983e83308f995d6284e9ba41"
 dependencies = [
  "bytes",
- "indexmap 2.13.0",
+ "indexmap 2.14.0",
  "serde",
  "serde_json",
 ]
@@ -554,7 +546,7 @@ dependencies = [
  "futures-lite",
  "parking",
  "polling",
- "rustix 1.1.3",
+ "rustix 1.1.4",
  "slab",
  "windows-sys 0.61.2",
 ]
@@ -589,7 +581,7 @@ dependencies = [
  "secrecy",
  "serde",
  "serde_json",
- "thiserror 2.0.17",
+ "thiserror 2.0.18",
  "tokio",
  "tokio-stream",
  "tokio-util",
@@ -604,7 +596,7 @@ checksum = "81872a8e595e8ceceab71c6ba1f9078e313b452a1e31934e6763ef5d308705e4"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -615,7 +607,7 @@ checksum = "3b43422f69d8ff38f95f1b2bb76517c91589a924d1559a0e935d7c8ce0274c11"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -637,7 +629,7 @@ checksum = "c7c24de15d275a1ecfd47a380fb4d5ec9bfe0933f309ed5e705b775596a3574d"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -648,7 +640,7 @@ checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -691,53 +683,11 @@ version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 
-[[package]]
-name = "aws-config"
-version = "1.8.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96571e6996817bf3d58f6b569e4b9fd2e9d2fcf9f7424eed07b2ce9bb87535e5"
-dependencies = [
- "aws-credential-types",
- "aws-runtime",
- "aws-sdk-sso",
- "aws-sdk-ssooidc",
- "aws-sdk-sts",
- "aws-smithy-async",
- "aws-smithy-http",
- "aws-smithy-json",
- "aws-smithy-runtime",
- "aws-smithy-runtime-api",
- "aws-smithy-types",
- "aws-types",
- "bytes",
- "fastrand",
- "hex",
- "http 1.4.0",
- "ring",
- "time",
- "tokio",
- "tracing",
- "url",
- "zeroize",
-]
-
-[[package]]
-name = "aws-credential-types"
-version = "1.2.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3cd362783681b15d136480ad555a099e82ecd8e2d10a841e14dfd0078d67fee3"
-dependencies = [
- "aws-smithy-async",
- "aws-smithy-runtime-api",
- "aws-smithy-types",
- "zeroize",
-]
-
 [[package]]
 name = "aws-lc-rs"
-version = "1.15.3"
+version = "1.16.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e84ce723ab67259cfeb9877c6a639ee9eb7a27b28123abd71db7f0d5d0cc9d86"
+checksum = "a054912289d18629dc78375ba2c3726a3afe3ff71b4edba9dedfca0e3446d1fc"
 dependencies = [
  "aws-lc-sys",
  "untrusted 0.7.1",
@@ -746,9 +696,9 @@ dependencies = [
 
 [[package]]
 name = "aws-lc-sys"
-version = "0.36.0"
+version = "0.39.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43a442ece363113bd4bd4c8b18977a7798dd4d3c3383f34fb61936960e8f4ad8"
+checksum = "83a25cf98105baa966497416dbd42565ce3a8cf8dbfd59803ec9ad46f3126399"
 dependencies = [
  "cc",
  "cmake",
@@ -756,325 +706,6 @@ dependencies = [
  "fs_extra",
 ]
 
-[[package]]
-name = "aws-runtime"
-version = "1.5.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "959dab27ce613e6c9658eb3621064d0e2027e5f2acb65bc526a43577facea557"
-dependencies = [
- "aws-credential-types",
- "aws-sigv4",
- "aws-smithy-async",
- "aws-smithy-http",
- "aws-smithy-runtime",
- "aws-smithy-runtime-api",
- "aws-smithy-types",
- "aws-types",
- "bytes",
- "fastrand",
- "http 0.2.12",
- "http-body 0.4.6",
- "percent-encoding",
- "pin-project-lite",
- "tracing",
- "uuid",
-]
-
-[[package]]
-name = "aws-sdk-dynamodb"
-version = "1.103.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6df2a8b03419775bfaf4f3ebbb65a9772e9e69eed4467a1b33f22226722340fb"
-dependencies = [
- "aws-credential-types",
- "aws-runtime",
- "aws-smithy-async",
- "aws-smithy-http",
- "aws-smithy-json",
- "aws-smithy-observability",
- "aws-smithy-runtime",
- "aws-smithy-runtime-api",
- "aws-smithy-types",
- "aws-types",
- "bytes",
- "fastrand",
- "http 0.2.12",
- "regex-lite",
- "tracing",
-]
-
-[[package]]
-name = "aws-sdk-sso"
-version = "1.92.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b7d63bd2bdeeb49aa3f9b00c15e18583503b778b2e792fc06284d54e7d5b6566"
-dependencies = [
- "aws-credential-types",
- "aws-runtime",
- "aws-smithy-async",
- "aws-smithy-http",
- "aws-smithy-json",
- "aws-smithy-observability",
- "aws-smithy-runtime",
- "aws-smithy-runtime-api",
- "aws-smithy-types",
- "aws-types",
- "bytes",
- "fastrand",
- "http 0.2.12",
- "regex-lite",
- "tracing",
-]
-
-[[package]]
-name = "aws-sdk-ssooidc"
-version = "1.94.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "532d93574bf731f311bafb761366f9ece345a0416dbcc273d81d6d1a1205239b"
-dependencies = [
- "aws-credential-types",
- "aws-runtime",
- "aws-smithy-async",
- "aws-smithy-http",
- "aws-smithy-json",
- "aws-smithy-observability",
- "aws-smithy-runtime",
- "aws-smithy-runtime-api",
- "aws-smithy-types",
- "aws-types",
- "bytes",
- "fastrand",
- "http 0.2.12",
- "regex-lite",
- "tracing",
-]
-
-[[package]]
-name = "aws-sdk-sts"
-version = "1.96.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "357e9a029c7524db6a0099cd77fbd5da165540339e7296cca603531bc783b56c"
-dependencies = [
- "aws-credential-types",
- "aws-runtime",
- "aws-smithy-async",
- "aws-smithy-http",
- "aws-smithy-json",
- "aws-smithy-observability",
- "aws-smithy-query",
- "aws-smithy-runtime",
- "aws-smithy-runtime-api",
- "aws-smithy-types",
- "aws-smithy-xml",
- "aws-types",
- "fastrand",
- "http 0.2.12",
- "regex-lite",
- "tracing",
-]
-
-[[package]]
-name = "aws-sigv4"
-version = "1.3.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69e523e1c4e8e7e8ff219d732988e22bfeae8a1cafdbe6d9eca1546fa080be7c"
-dependencies = [
- "aws-credential-types",
- "aws-smithy-http",
- "aws-smithy-runtime-api",
- "aws-smithy-types",
- "bytes",
- "form_urlencoded",
- "hex",
- "hmac",
- "http 0.2.12",
- "http 1.4.0",
- "percent-encoding",
- "sha2",
- "time",
- "tracing",
-]
-
-[[package]]
-name = "aws-smithy-async"
-version = "1.2.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ee19095c7c4dda59f1697d028ce704c24b2d33c6718790c7f1d5a3015b4107c"
-dependencies = [
- "futures-util",
- "pin-project-lite",
- "tokio",
-]
-
-[[package]]
-name = "aws-smithy-http"
-version = "0.62.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "826141069295752372f8203c17f28e30c464d22899a43a0c9fd9c458d469c88b"
-dependencies = [
- "aws-smithy-runtime-api",
- "aws-smithy-types",
- "bytes",
- "bytes-utils",
- "futures-core",
- "futures-util",
- "http 0.2.12",
- "http 1.4.0",
- "http-body 0.4.6",
- "percent-encoding",
- "pin-project-lite",
- "pin-utils",
- "tracing",
-]
-
-[[package]]
-name = "aws-smithy-http-client"
-version = "1.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59e62db736db19c488966c8d787f52e6270be565727236fd5579eaa301e7bc4a"
-dependencies = [
- "aws-smithy-async",
- "aws-smithy-runtime-api",
- "aws-smithy-types",
- "h2 0.3.27",
- "h2 0.4.13",
- "http 0.2.12",
- "http 1.4.0",
- "http-body 0.4.6",
- "hyper 0.14.32",
- "hyper 1.8.1",
- "hyper-rustls 0.24.2",
- "hyper-rustls 0.27.7",
- "hyper-util",
- "pin-project-lite",
- "rustls 0.21.12",
- "rustls 0.23.36",
- "rustls-native-certs 0.8.3",
- "rustls-pki-types",
- "tokio",
- "tokio-rustls 0.26.4",
- "tower 0.5.3",
- "tracing",
-]
-
-[[package]]
-name = "aws-smithy-json"
-version = "0.61.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49fa1213db31ac95288d981476f78d05d9cbb0353d22cdf3472cc05bb02f6551"
-dependencies = [
- "aws-smithy-types",
-]
-
-[[package]]
-name = "aws-smithy-observability"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef1fcbefc7ece1d70dcce29e490f269695dfca2d2bacdeaf9e5c3f799e4e6a42"
-dependencies = [
- "aws-smithy-runtime-api",
-]
-
-[[package]]
-name = "aws-smithy-query"
-version = "0.60.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae5d689cf437eae90460e944a58b5668530d433b4ff85789e69d2f2a556e057d"
-dependencies = [
- "aws-smithy-types",
- "urlencoding",
-]
-
-[[package]]
-name = "aws-smithy-runtime"
-version = "1.9.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb5b6167fcdf47399024e81ac08e795180c576a20e4d4ce67949f9a88ae37dc1"
-dependencies = [
- "aws-smithy-async",
- "aws-smithy-http",
- "aws-smithy-http-client",
- "aws-smithy-observability",
- "aws-smithy-runtime-api",
- "aws-smithy-types",
- "bytes",
- "fastrand",
- "http 0.2.12",
- "http 1.4.0",
- "http-body 0.4.6",
- "http-body 1.0.1",
- "pin-project-lite",
- "pin-utils",
- "tokio",
- "tracing",
-]
-
-[[package]]
-name = "aws-smithy-runtime-api"
-version = "1.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "efce7aaaf59ad53c5412f14fc19b2d5c6ab2c3ec688d272fd31f76ec12f44fb0"
-dependencies = [
- "aws-smithy-async",
- "aws-smithy-types",
- "bytes",
- "http 0.2.12",
- "http 1.4.0",
- "pin-project-lite",
- "tokio",
- "tracing",
- "zeroize",
-]
-
-[[package]]
-name = "aws-smithy-types"
-version = "1.4.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2b1117b3b2bbe166d11199b540ceed0d0f7676e36e7b962b5a437a9971eac75"
-dependencies = [
- "base64-simd",
- "bytes",
- "bytes-utils",
- "futures-core",
- "http 0.2.12",
- "http 1.4.0",
- "http-body 0.4.6",
- "http-body 1.0.1",
- "http-body-util",
- "itoa",
- "num-integer",
- "pin-project-lite",
- "pin-utils",
- "ryu",
- "serde",
- "time",
- "tokio",
- "tokio-util",
-]
-
-[[package]]
-name = "aws-smithy-xml"
-version = "0.60.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11b2f670422ff42bf7065031e72b45bc52a3508bd089f743ea90731ca2b6ea57"
-dependencies = [
- "xmlparser",
-]
-
-[[package]]
-name = "aws-types"
-version = "1.3.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d980627d2dd7bfc32a3c025685a033eeab8d365cc840c631ef59d1b8f428164"
-dependencies = [
- "aws-credential-types",
- "aws-smithy-async",
- "aws-smithy-runtime-api",
- "aws-smithy-types",
- "rustc_version",
- "tracing",
-]
-
 [[package]]
 name = "axum"
 version = "0.7.9"
@@ -1085,8 +716,8 @@ dependencies = [
  "axum-core 0.4.5",
  "bytes",
  "futures-util",
- "http 1.4.0",
- "http-body 1.0.1",
+ "http",
+ "http-body",
  "http-body-util",
  "itoa",
  "matchit 0.7.3",
@@ -1104,18 +735,18 @@ dependencies = [
 
 [[package]]
 name = "axum"
-version = "0.8.8"
+version = "0.8.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b52af3cb4058c895d37317bb27508dccc8e5f2d39454016b297bf4a400597b8"
+checksum = "31b698c5f9a010f6573133b09e0de5408834d0c82f8d7475a89fc1867a71cd90"
 dependencies = [
  "axum-core 0.5.6",
  "bytes",
  "form_urlencoded",
  "futures-util",
- "http 1.4.0",
- "http-body 1.0.1",
+ "http",
+ "http-body",
  "http-body-util",
- "hyper 1.8.1",
+ "hyper",
  "hyper-util",
  "itoa",
  "matchit 0.8.4",
@@ -1144,8 +775,8 @@ dependencies = [
  "async-trait",
  "bytes",
  "futures-util",
- "http 1.4.0",
- "http-body 1.0.1",
+ "http",
+ "http-body",
  "http-body-util",
  "mime",
  "pin-project-lite",
@@ -1163,8 +794,8 @@ checksum = "08c78f31d7b1291f7ee735c1c6780ccde7785daae9a9206026862dab7d8792d1"
 dependencies = [
  "bytes",
  "futures-core",
- "http 1.4.0",
- "http-body 1.0.1",
+ "http",
+ "http-body",
  "http-body-util",
  "mime",
  "pin-project-lite",
@@ -1188,17 +819,6 @@ dependencies = [
  "tokio",
 ]
 
-[[package]]
-name = "backon"
-version = "1.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cffb0e931875b666fc4fcb20fee52e9bbd1ef836fd9e9e04ec21555f9f85f7ef"
-dependencies = [
- "fastrand",
- "gloo-timers",
- "tokio",
-]
-
 [[package]]
 name = "base64"
 version = "0.21.7"
@@ -1220,22 +840,6 @@ dependencies = [
  "byteorder",
 ]
 
-[[package]]
-name = "base64-simd"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "339abbe78e73178762e23bea9dfd08e697eb3f3301cd4be981c0f78ba5859195"
-dependencies = [
- "outref",
- "vsimd",
-]
-
-[[package]]
-name = "base64ct"
-version = "1.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06"
-
 [[package]]
 name = "bigdecimal"
 version = "0.4.10"
@@ -1259,6 +863,26 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "bincode"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36eaf5d7b090263e8150820482d5d93cd964a81e4019913c972f4edcc6edb740"
+dependencies = [
+ "bincode_derive",
+ "serde",
+ "unty",
+]
+
+[[package]]
+name = "bincode_derive"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf95709a440f45e986983918d0e8a1f30a9b1df04918fc828670606804ac3c09"
+dependencies = [
+ "virtue",
+]
+
 [[package]]
 name = "bit-set"
 version = "0.8.0"
@@ -1276,9 +900,9 @@ checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"
 
 [[package]]
 name = "bitflags"
-version = "2.10.0"
+version = "2.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3"
+checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3"
 dependencies = [
  "serde_core",
 ]
@@ -1315,16 +939,16 @@ dependencies = [
 
 [[package]]
 name = "blake3"
-version = "1.8.3"
+version = "1.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2468ef7d57b3fb7e16b576e8377cdbde2320c60e1491e961d11da40fc4f02a2d"
+checksum = "4d2d5991425dfd0785aed03aedcf0b321d61975c9b5b3689c774a2610ae0b51e"
 dependencies = [
  "arrayref",
  "arrayvec",
  "cc",
  "cfg-if",
  "constant_time_eq 0.4.2",
- "cpufeatures",
+ "cpufeatures 0.3.0",
 ]
 
 [[package]]
@@ -1336,20 +960,11 @@ dependencies = [
  "generic-array",
 ]
 
-[[package]]
-name = "block-padding"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8894febbff9f758034a5b8e12d87918f56dfc64a8e1fe757d65e29041538d93"
-dependencies = [
- "generic-array",
-]
-
 [[package]]
 name = "bon"
-version = "3.8.2"
+version = "3.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "234655ec178edd82b891e262ea7cf71f6584bcd09eff94db786be23f1821825c"
+checksum = "f47dbe92550676ee653353c310dfb9cf6ba17ee70396e1f7cf0a2020ad49b2fe"
 dependencies = [
  "bon-macros",
  "rustversion",
@@ -1357,9 +972,9 @@ dependencies = [
 
 [[package]]
 name = "bon-macros"
-version = "3.8.2"
+version = "3.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89ec27229c38ed0eb3c0feee3d2c1d6a4379ae44f418a29a658890e062d8f365"
+checksum = "519bd3116aeeb42d5372c29d982d16d0170d3d4a5ed85fc7dd91642ffff3c67c"
 dependencies = [
  "darling 0.23.0",
  "ident_case",
@@ -1367,19 +982,14 @@ dependencies = [
  "proc-macro2",
  "quote",
  "rustversion",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
-name = "brotli"
-version = "7.0.0"
+name = "boxcar"
+version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc97b8f16f944bba54f0433f07e30be199b6dc2bd25937444bbad560bcea29bd"
-dependencies = [
- "alloc-no-stdlib",
- "alloc-stdlib",
- "brotli-decompressor 4.0.3",
-]
+checksum = "36f64beae40a84da1b4b26ff2761a5b895c12adc41dc25aaee1c4f2bbfe97a6e"
 
 [[package]]
 name = "brotli"
@@ -1389,17 +999,7 @@ checksum = "4bd8b9603c7aa97359dbd97ecf258968c95f3adddd6db2f7e7a5bef101c84560"
 dependencies = [
  "alloc-no-stdlib",
  "alloc-stdlib",
- "brotli-decompressor 5.0.0",
-]
-
-[[package]]
-name = "brotli-decompressor"
-version = "4.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a334ef7c9e23abf0ce748e8cd309037da93e606ad52eb372e4ce327a0dcfbdfd"
-dependencies = [
- "alloc-no-stdlib",
- "alloc-stdlib",
+ "brotli-decompressor",
 ]
 
 [[package]]
@@ -1414,15 +1014,15 @@ dependencies = [
 
 [[package]]
 name = "bumpalo"
-version = "3.19.1"
+version = "3.20.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5dd9dc738b7a8311c7ade152424974d8115f2cdad61e8dab8dac9f2362298510"
+checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb"
 
 [[package]]
 name = "bytemuck"
-version = "1.24.0"
+version = "1.25.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fbdf580320f38b612e485521afda1ee26d10cc9884efaaa750d383e13e3c5f4"
+checksum = "c8efb64bd706a16a1bdde310ae86b351e4d21550d98d056f22f8a7f7a2183fec"
 dependencies = [
  "bytemuck_derive",
 ]
@@ -1435,7 +1035,7 @@ checksum = "f9abbd1bc6865053c427f7198e6af43bfdedc55ab791faed4fbd361d789575ff"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -1453,16 +1053,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "bytes-utils"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7dafe3a8757b027e2be6e4e5601ed563c55989fcf1546e933c66c8eb3a058d35"
-dependencies = [
- "bytes",
- "either",
-]
-
 [[package]]
 name = "bzip2"
 version = "0.4.4"
@@ -1482,15 +1072,6 @@ dependencies = [
  "bzip2-sys",
 ]
 
-[[package]]
-name = "bzip2"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3a53fac24f34a81bc9954b5d6cfce0c21e18ec6959f44f56e8e90e4bb7c346c"
-dependencies = [
- "libbz2-rs-sys",
-]
-
 [[package]]
 name = "bzip2-sys"
 version = "0.1.13+1.0.8"
@@ -1507,20 +1088,11 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
-[[package]]
-name = "cbc"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26b52a9543ae338f279b96b0b9fed9c8093744685043739079ce85cd58f289a6"
-dependencies = [
- "cipher",
-]
-
 [[package]]
 name = "cc"
-version = "1.2.52"
+version = "1.2.60"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd4932aefd12402b36c60956a4fe0035421f544799057659ff86f923657aada3"
+checksum = "43c5703da9466b66a946814e1adf53ea2c90f10063b86290cc9eb67ce3478a20"
 dependencies = [
  "find-msvc-tools",
  "jobserver",
@@ -1548,9 +1120,9 @@ checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
 
 [[package]]
 name = "chrono"
-version = "0.4.42"
+version = "0.4.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "145052bdd345b87320e369255277e3fb5152762ad123a901ef5c262dd38fe8d2"
+checksum = "c673075a2e0e5f4a1dde27ce9dee1ea4558c7ffe648f576438a20ca1d2acc4b0"
 dependencies = [
  "iana-time-zone",
  "js-sys",
@@ -1629,11 +1201,55 @@ dependencies = [
  "inout",
 ]
 
+[[package]]
+name = "clam-core"
+version = "0.18.0"
+dependencies = [
+ "ahash",
+ "arrow",
+ "async-trait",
+ "chrono",
+ "chrono-tz 0.10.4",
+ "comfy-table",
+ "criterion",
+ "db4-storage",
+ "env_logger 0.10.2",
+ "fastrand",
+ "flate2",
+ "insta",
+ "itertools 0.13.0",
+ "log",
+ "nom 7.1.3",
+ "optd-core",
+ "parking_lot",
+ "proptest",
+ "pyo3",
+ "raphtory",
+ "raphtory-api",
+ "raphtory-itertools",
+ "raphtory-storage",
+ "rayon",
+ "regex",
+ "roaring 0.10.12",
+ "rustyline",
+ "serde",
+ "serde_json",
+ "slotmap",
+ "snb",
+ "tempfile",
+ "thiserror 2.0.18",
+ "tikv-jemallocator",
+ "tokio",
+ "tracing",
+ "tracing-test",
+ "uuid",
+]
+
 [[package]]
 name = "clap"
-version = "4.5.54"
+version = "4.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c6e6ff9dcd79cff5cd969a17a545d79e84ab086e444102a591e288a8aa3ce394"
+checksum = "b193af5b67834b676abd72466a96c1024e6a6ad978a1f484bd90b85c94041351"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -1641,9 +1257,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.54"
+version = "4.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa42cf4d2b7a41bc8f663a7cab4031ebafa1bf3875705bfaf8466dc60ab52c00"
+checksum = "714a53001bf66416adb0e2ef5ac857140e7dc3a0c48fb28b2f10762fc4b5069f"
 dependencies = [
  "anstream",
  "anstyle",
@@ -1653,48 +1269,77 @@ dependencies = [
 
 [[package]]
 name = "clap_derive"
-version = "4.5.49"
+version = "4.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a0b5487afeab2deb2ff4e03a807ad1a03ac532ff5a2cee5d86884440c7f7671"
+checksum = "1110bd8a634a1ab8cb04345d8d878267d57c3cf1b38d91b71af6686408bbca6a"
 dependencies = [
  "heck 0.5.0",
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
 name = "clap_lex"
-version = "0.7.7"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9"
+
+[[package]]
+name = "clipboard-win"
+version = "5.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3e64b0cc0439b12df2fa678eae89a1c56a529fd067a9115f7827f1fffd22b32"
+checksum = "bde03770d3df201d4fb868f2c9c59e66a3e4e2bd06692a0fe701e7103c7e84d4"
+dependencies = [
+ "error-code",
+]
 
 [[package]]
 name = "cmake"
-version = "0.1.57"
+version = "0.1.58"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75443c44cd6b379beb8c5b45d85d0773baf31cce901fe7bb252f4eff3008ef7d"
+checksum = "c0f78a02292a74a88ac736019ab962ece0bc380e3f977bf72e376c5d78ff0678"
 dependencies = [
  "cc",
 ]
 
 [[package]]
 name = "colorchoice"
-version = "1.0.4"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
+checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"
 
 [[package]]
 name = "comfy-table"
-version = "7.1.2"
+version = "7.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0d05af1e006a2407bedef5af410552494ce5be9090444dbbcb57258c1af3d56"
+checksum = "958c5d6ecf1f214b4c2bbbbf6ab9523a864bd136dcf71a7e8904799acfe1ad47"
 dependencies = [
- "strum 0.26.3",
- "strum_macros 0.26.4",
- "unicode-width",
+ "crossterm",
+ "unicode-segmentation",
+ "unicode-width 0.2.2",
+]
+
+[[package]]
+name = "compression-codecs"
+version = "0.4.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb7b51a7d9c967fc26773061ba86150f19c50c0d65c887cb1fbe295fd16619b7"
+dependencies = [
+ "brotli",
+ "compression-core",
+ "flate2",
+ "memchr",
+ "zstd",
+ "zstd-safe",
 ]
 
+[[package]]
+name = "compression-core"
+version = "0.4.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75984efb6ed102a0d42db99afb6c1948f0380d1d91808d5529916e6c08b49d8d"
+
 [[package]]
 name = "concurrent-queue"
 version = "2.5.0"
@@ -1716,13 +1361,24 @@ dependencies = [
  "nom 7.1.3",
  "pathdiff",
  "ron",
- "rust-ini 0.20.0",
+ "rust-ini",
  "serde",
  "serde_json",
  "toml",
  "yaml-rust2",
 ]
 
+[[package]]
+name = "console"
+version = "0.16.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d64e8af5551369d19cf50138de61f1c42074ab970f74e99be916646777f8fc87"
+dependencies = [
+ "encode_unicode",
+ "libc",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "const-oid"
 version = "0.9.6"
@@ -1805,6 +1461,15 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "cpufeatures"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b2a41393f66f16b0823bb79094d54ac5fbd34ab292ddafb9a0456ac9f87d201"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "crc"
 version = "3.4.0"
@@ -1820,15 +1485,6 @@ version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "19d374276b40fb8bbdee95aef7c7fa6b5316ec764510eb64b8dd0e2ed0d7e7f5"
 
-[[package]]
-name = "crc32c"
-version = "0.6.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3a47af21622d091a8f0fb295b88bc886ac74efcc613efc19f5d0b21de5c89e47"
-dependencies = [
- "rustc_version",
-]
-
 [[package]]
 name = "crc32fast"
 version = "1.5.0"
@@ -1911,12 +1567,45 @@ dependencies = [
  "crossbeam-utils",
 ]
 
+[[package]]
+name = "crossbeam-skiplist"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df29de440c58ca2cc6e587ec3d22347551a32435fbde9d2bff64e78a9ffa151b"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
 [[package]]
 name = "crossbeam-utils"
 version = "0.8.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
+[[package]]
+name = "crossterm"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8b9f2e4c67f833b660cdb0a3523065869fb35570177239812ed4c905aeff87b"
+dependencies = [
+ "bitflags",
+ "crossterm_winapi",
+ "document-features",
+ "parking_lot",
+ "rustix 1.1.4",
+ "winapi",
+]
+
+[[package]]
+name = "crossterm_winapi"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "acdd7c62a3665c7f6830a51635d9ac9b23ed385797f70a83bb8bafe9c572ab2b"
+dependencies = [
+ "winapi",
+]
+
 [[package]]
 name = "crunchy"
 version = "0.2.4"
@@ -1925,9 +1614,9 @@ checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
 
 [[package]]
 name = "crypto-common"
-version = "0.1.7"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
 dependencies = [
  "generic-array",
  "typenum",
@@ -1964,16 +1653,6 @@ dependencies = [
  "darling_macro 0.20.11",
 ]
 
-[[package]]
-name = "darling"
-version = "0.21.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9cdf337090841a411e2a7f3deb9187445851f91b309c0c0a29e05f74a00a48c0"
-dependencies = [
- "darling_core 0.21.3",
- "darling_macro 0.21.3",
-]
-
 [[package]]
 name = "darling"
 version = "0.23.0"
@@ -1995,21 +1674,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "strsim",
- "syn 2.0.114",
-]
-
-[[package]]
-name = "darling_core"
-version = "0.21.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1247195ecd7e3c85f83c8d2a366e4210d588e802133e1e355180a9870b517ea4"
-dependencies = [
- "fnv",
- "ident_case",
- "proc-macro2",
- "quote",
- "strsim",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -2022,7 +1687,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "strsim",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -2033,18 +1698,7 @@ checksum = "fc34b93ccb385b40dc71c6fceac4b2ad23662c7eeb248cf10d529b7e055b6ead"
 dependencies = [
  "darling_core 0.20.11",
  "quote",
- "syn 2.0.114",
-]
-
-[[package]]
-name = "darling_macro"
-version = "0.21.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d38308df82d1080de0afee5d069fa14b0326a88c14f15c5ccda35b4a6c414c81"
-dependencies = [
- "darling_core 0.21.3",
- "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -2055,7 +1709,7 @@ checksum = "ac3984ec7bd6cfa798e62b4a642426a5be0e68f9401cfc2a01e3fa9ea2fcdb8d"
 dependencies = [
  "darling_core 0.23.0",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -2082,25 +1736,23 @@ checksum = "d7a1e2f27636f116493b8b860f5546edb47c8d8f8ea73e1d2a20be88e28d1fea"
 
 [[package]]
 name = "datafusion"
-version = "50.3.0"
+version = "52.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2af15bb3c6ffa33011ef579f6b0bcbe7c26584688bd6c994f548e44df67f011a"
+checksum = "7541353e77dc7262b71ca27be07d8393661737e3a73b5d1b1c6f7d814c64fa2a"
 dependencies = [
  "arrow",
- "arrow-ipc",
  "arrow-schema",
  "async-trait",
  "bytes",
- "bzip2 0.6.1",
  "chrono",
  "datafusion-catalog",
  "datafusion-catalog-listing",
  "datafusion-common",
  "datafusion-common-runtime",
  "datafusion-datasource",
+ "datafusion-datasource-arrow",
  "datafusion-datasource-csv",
  "datafusion-datasource-json",
- "datafusion-datasource-parquet",
  "datafusion-execution",
  "datafusion-expr",
  "datafusion-expr-common",
@@ -2117,29 +1769,25 @@ dependencies = [
  "datafusion-physical-plan",
  "datafusion-session",
  "datafusion-sql",
- "flate2",
  "futures",
  "itertools 0.14.0",
  "log",
  "object_store",
  "parking_lot",
- "parquet",
- "rand 0.9.2",
+ "rand 0.9.4",
  "regex",
  "sqlparser",
  "tempfile",
  "tokio",
  "url",
  "uuid",
- "xz2",
- "zstd",
 ]
 
 [[package]]
 name = "datafusion-catalog"
-version = "50.3.0"
+version = "52.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "187622262ad8f7d16d3be9202b4c1e0116f1c9aa387e5074245538b755261621"
+checksum = "9997731f90fa5398ef831ad0e69600f92c861b79c0d38bd1a29b6f0e3a0ce4c8"
 dependencies = [
  "arrow",
  "async-trait",
@@ -2152,7 +1800,6 @@ dependencies = [
  "datafusion-physical-expr",
  "datafusion-physical-plan",
  "datafusion-session",
- "datafusion-sql",
  "futures",
  "itertools 0.14.0",
  "log",
@@ -2163,9 +1810,9 @@ dependencies = [
 
 [[package]]
 name = "datafusion-catalog-listing"
-version = "50.3.0"
+version = "52.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9657314f0a32efd0382b9a46fdeb2d233273ece64baa68a7c45f5a192daf0f83"
+checksum = "2b30a3dd50dec860c9559275c8d97d9de602e611237a6ecfbda0b3b63b872352"
 dependencies = [
  "arrow",
  "async-trait",
@@ -2175,35 +1822,32 @@ dependencies = [
  "datafusion-execution",
  "datafusion-expr",
  "datafusion-physical-expr",
+ "datafusion-physical-expr-adapter",
  "datafusion-physical-expr-common",
  "datafusion-physical-plan",
- "datafusion-session",
  "futures",
+ "itertools 0.14.0",
  "log",
  "object_store",
- "tokio",
 ]
 
 [[package]]
 name = "datafusion-common"
-version = "50.3.0"
+version = "52.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a83760d9a13122d025fbdb1d5d5aaf93dd9ada5e90ea229add92aa30898b2d1"
+checksum = "d551054acec0398ca604512310b77ce05c46f66e54b54d48200a686e385cca4e"
 dependencies = [
  "ahash",
  "arrow",
  "arrow-ipc",
- "base64 0.22.1",
  "chrono",
  "half",
- "hashbrown 0.14.5",
- "indexmap 2.13.0",
+ "hashbrown 0.16.1",
+ "indexmap 2.14.0",
  "libc",
  "log",
  "object_store",
- "parquet",
  "paste",
- "recursive",
  "sqlparser",
  "tokio",
  "web-time",
@@ -2211,9 +1855,9 @@ dependencies = [
 
 [[package]]
 name = "datafusion-common-runtime"
-version = "50.3.0"
+version = "52.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b6234a6c7173fe5db1c6c35c01a12b2aa0f803a3007feee53483218817f8b1e"
+checksum = "567d40e285f5b79f8737b576605721cd6c1133b5d2b00bdbd5d9838d90d0812f"
 dependencies = [
  "futures",
  "log",
@@ -2222,15 +1866,13 @@ dependencies = [
 
 [[package]]
 name = "datafusion-datasource"
-version = "50.3.0"
+version = "52.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7256c9cb27a78709dd42d0c80f0178494637209cac6e29d5c93edd09b6721b86"
+checksum = "27d2668f51b3b30befae2207472569e37807fdedd1d14da58acc6f8ca6257eae"
 dependencies = [
  "arrow",
- "async-compression",
  "async-trait",
  "bytes",
- "bzip2 0.6.1",
  "chrono",
  "datafusion-common",
  "datafusion-common-runtime",
@@ -2241,119 +1883,100 @@ dependencies = [
  "datafusion-physical-expr-common",
  "datafusion-physical-plan",
  "datafusion-session",
- "flate2",
  "futures",
  "glob",
  "itertools 0.14.0",
  "log",
  "object_store",
- "parquet",
- "rand 0.9.2",
- "tempfile",
+ "rand 0.9.4",
  "tokio",
- "tokio-util",
  "url",
- "xz2",
- "zstd",
 ]
 
 [[package]]
-name = "datafusion-datasource-csv"
-version = "50.3.0"
+name = "datafusion-datasource-arrow"
+version = "52.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64533a90f78e1684bfb113d200b540f18f268134622d7c96bbebc91354d04825"
+checksum = "e02e1b3e3a8ec55f1f62de4252b0407c8567363d056078769a197e24fc834a0f"
 dependencies = [
  "arrow",
+ "arrow-ipc",
  "async-trait",
  "bytes",
- "datafusion-catalog",
  "datafusion-common",
  "datafusion-common-runtime",
  "datafusion-datasource",
  "datafusion-execution",
  "datafusion-expr",
- "datafusion-physical-expr",
  "datafusion-physical-expr-common",
  "datafusion-physical-plan",
  "datafusion-session",
  "futures",
+ "itertools 0.14.0",
  "object_store",
- "regex",
  "tokio",
 ]
 
 [[package]]
-name = "datafusion-datasource-json"
-version = "50.3.0"
+name = "datafusion-datasource-csv"
+version = "52.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d7ebeb12c77df0aacad26f21b0d033aeede423a64b2b352f53048a75bf1d6e6"
+checksum = "b559d7bf87d4f900f847baba8509634f838d9718695389e903604cdcccdb01f3"
 dependencies = [
  "arrow",
  "async-trait",
  "bytes",
- "datafusion-catalog",
  "datafusion-common",
  "datafusion-common-runtime",
  "datafusion-datasource",
  "datafusion-execution",
  "datafusion-expr",
- "datafusion-physical-expr",
  "datafusion-physical-expr-common",
  "datafusion-physical-plan",
  "datafusion-session",
  "futures",
  "object_store",
- "serde_json",
+ "regex",
  "tokio",
 ]
 
 [[package]]
-name = "datafusion-datasource-parquet"
-version = "50.3.0"
+name = "datafusion-datasource-json"
+version = "52.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09e783c4c7d7faa1199af2df4761c68530634521b176a8d1331ddbc5a5c75133"
+checksum = "250e2d7591ba8b638f063854650faa40bca4e8bd4059b2ece8836f6388d02db4"
 dependencies = [
  "arrow",
  "async-trait",
  "bytes",
- "datafusion-catalog",
  "datafusion-common",
  "datafusion-common-runtime",
  "datafusion-datasource",
  "datafusion-execution",
  "datafusion-expr",
- "datafusion-functions-aggregate",
- "datafusion-physical-expr",
- "datafusion-physical-expr-adapter",
  "datafusion-physical-expr-common",
- "datafusion-physical-optimizer",
  "datafusion-physical-plan",
- "datafusion-pruning",
  "datafusion-session",
  "futures",
- "itertools 0.14.0",
- "log",
  "object_store",
- "parking_lot",
- "parquet",
- "rand 0.9.2",
  "tokio",
 ]
 
 [[package]]
 name = "datafusion-doc"
-version = "50.3.0"
+version = "52.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99ee6b1d9a80d13f9deb2291f45c07044b8e62fb540dbde2453a18be17a36429"
+checksum = "b9496cb0db222dbb9a3735760ceca7fc56f35e1d5502c38d0caa77a81e9c1f6a"
 
 [[package]]
 name = "datafusion-execution"
-version = "50.3.0"
+version = "52.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4cec0a57653bec7b933fb248d3ffa3fa3ab3bd33bd140dc917f714ac036f531"
+checksum = "dc45d23c516ed8d3637751e44e09e21b45b3f58b473c802dddd1f1ad4fe435ff"
 dependencies = [
  "arrow",
  "async-trait",
+ "chrono",
  "dashmap",
  "datafusion-common",
  "datafusion-expr",
@@ -2361,16 +1984,16 @@ dependencies = [
  "log",
  "object_store",
  "parking_lot",
- "rand 0.9.2",
+ "rand 0.9.4",
  "tempfile",
  "url",
 ]
 
 [[package]]
 name = "datafusion-expr"
-version = "50.3.0"
+version = "52.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef76910bdca909722586389156d0aa4da4020e1631994d50fadd8ad4b1aa05fe"
+checksum = "63dd30526d2db4fda6440806a41e4676334a94bc0596cc9cc2a0efed20ef2c44"
 dependencies = [
  "arrow",
  "async-trait",
@@ -2381,31 +2004,31 @@ dependencies = [
  "datafusion-functions-aggregate-common",
  "datafusion-functions-window-common",
  "datafusion-physical-expr-common",
- "indexmap 2.13.0",
+ "indexmap 2.14.0",
+ "itertools 0.14.0",
  "paste",
- "recursive",
  "serde_json",
  "sqlparser",
 ]
 
 [[package]]
 name = "datafusion-expr-common"
-version = "50.3.0"
+version = "52.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d155ccbda29591ca71a1344dd6bed26c65a4438072b400df9db59447f590bb6"
+checksum = "1b486b5f6255d40976b88bb83813b0d035a8333e0ec39864824e78068cf42fa6"
 dependencies = [
  "arrow",
  "datafusion-common",
- "indexmap 2.13.0",
+ "indexmap 2.14.0",
  "itertools 0.14.0",
  "paste",
 ]
 
 [[package]]
 name = "datafusion-functions"
-version = "50.3.0"
+version = "52.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7de2782136bd6014670fd84fe3b0ca3b3e4106c96403c3ae05c0598577139977"
+checksum = "07356c94118d881130dd0ffbff127540407d969c8978736e324edcd6c41cd48f"
 dependencies = [
  "arrow",
  "arrow-buffer",
@@ -2413,6 +2036,7 @@ dependencies = [
  "blake2",
  "blake3",
  "chrono",
+ "chrono-tz 0.10.4",
  "datafusion-common",
  "datafusion-doc",
  "datafusion-execution",
@@ -2423,7 +2047,8 @@ dependencies = [
  "itertools 0.14.0",
  "log",
  "md-5",
- "rand 0.9.2",
+ "num-traits",
+ "rand 0.9.4",
  "regex",
  "sha2",
  "unicode-segmentation",
@@ -2432,9 +2057,9 @@ dependencies = [
 
 [[package]]
 name = "datafusion-functions-aggregate"
-version = "50.3.0"
+version = "52.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07331fc13603a9da97b74fd8a273f4238222943dffdbbed1c4c6f862a30105bf"
+checksum = "b644f9cf696df9233ce6958b9807666d78563b56f923267474dd6c07795f1f8f"
 dependencies = [
  "ahash",
  "arrow",
@@ -2453,9 +2078,9 @@ dependencies = [
 
 [[package]]
 name = "datafusion-functions-aggregate-common"
-version = "50.3.0"
+version = "52.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5951e572a8610b89968a09b5420515a121fbc305c0258651f318dc07c97ab17"
+checksum = "c1de2deaaabe8923ce9ea9f29c47bbb4ee14f67ea2fe1ab5398d9bbebcf86e56"
 dependencies = [
  "ahash",
  "arrow",
@@ -2466,9 +2091,9 @@ dependencies = [
 
 [[package]]
 name = "datafusion-functions-nested"
-version = "50.3.0"
+version = "52.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fdacca9302c3d8fc03f3e94f338767e786a88a33f5ebad6ffc0e7b50364b9ea3"
+checksum = "552f8d92e4331ee91d23c02d12bb6acf32cbfd5215117e01c0fb63cd4b15af1a"
 dependencies = [
  "arrow",
  "arrow-ord",
@@ -2476,6 +2101,7 @@ dependencies = [
  "datafusion-doc",
  "datafusion-execution",
  "datafusion-expr",
+ "datafusion-expr-common",
  "datafusion-functions",
  "datafusion-functions-aggregate",
  "datafusion-functions-aggregate-common",
@@ -2488,9 +2114,9 @@ dependencies = [
 
 [[package]]
 name = "datafusion-functions-table"
-version = "50.3.0"
+version = "52.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c37ff8a99434fbbad604a7e0669717c58c7c4f14c472d45067c4b016621d981"
+checksum = "970fd0cdd3df8802b9a9975ff600998289ba9d46682a4f7285cba4820c9ada78"
 dependencies = [
  "arrow",
  "async-trait",
@@ -2504,9 +2130,9 @@ dependencies = [
 
 [[package]]
 name = "datafusion-functions-window"
-version = "50.3.0"
+version = "52.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48e2aea7c79c926cffabb13dc27309d4eaeb130f4a21c8ba91cdd241c813652b"
+checksum = "40b4c21a7c8a986a1866c0a87ab756d0bbf7b5f41f306009fa2d9af79c52ed31"
 dependencies = [
  "arrow",
  "datafusion-common",
@@ -2522,9 +2148,9 @@ dependencies = [
 
 [[package]]
 name = "datafusion-functions-window-common"
-version = "50.3.0"
+version = "52.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fead257ab5fd2ffc3b40fda64da307e20de0040fe43d49197241d9de82a487f"
+checksum = "b1210ad73b8b3211aeaf4a42bef9bd7a2b7fce3ec119a478831f18c6ff7f7b93"
 dependencies = [
  "datafusion-common",
  "datafusion-physical-expr-common",
@@ -2532,20 +2158,20 @@ dependencies = [
 
 [[package]]
 name = "datafusion-macros"
-version = "50.3.0"
+version = "52.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec6f637bce95efac05cdfb9b6c19579ed4aa5f6b94d951cfa5bb054b7bb4f730"
+checksum = "aaa566a963013a38681ad82a727a654bc7feb19632426aea8c3412d415d200c5"
 dependencies = [
- "datafusion-expr",
+ "datafusion-doc",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
 name = "datafusion-optimizer"
-version = "50.3.0"
+version = "52.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c6583ef666ae000a613a837e69e456681a9faa96347bf3877661e9e89e141d8a"
+checksum = "ff9aa82b240252a88dee118372f9b9757c545ab9e53c0736bebab2e7da0ef1f2"
 dependencies = [
  "arrow",
  "chrono",
@@ -2553,19 +2179,18 @@ dependencies = [
  "datafusion-expr",
  "datafusion-expr-common",
  "datafusion-physical-expr",
- "indexmap 2.13.0",
+ "indexmap 2.14.0",
  "itertools 0.14.0",
  "log",
- "recursive",
  "regex",
  "regex-syntax",
 ]
 
 [[package]]
 name = "datafusion-physical-expr"
-version = "50.3.0"
+version = "52.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8668103361a272cbbe3a61f72eca60c9b7c706e87cc3565bcf21e2b277b84f6"
+checksum = "7d48022b8af9988c1d852644f9e8b5584c490659769a550c5e8d39457a1da0a5"
 dependencies = [
  "ahash",
  "arrow",
@@ -2575,20 +2200,20 @@ dependencies = [
  "datafusion-functions-aggregate-common",
  "datafusion-physical-expr-common",
  "half",
- "hashbrown 0.14.5",
- "indexmap 2.13.0",
+ "hashbrown 0.16.1",
+ "indexmap 2.14.0",
  "itertools 0.14.0",
- "log",
  "parking_lot",
  "paste",
  "petgraph 0.8.3",
+ "tokio",
 ]
 
 [[package]]
 name = "datafusion-physical-expr-adapter"
-version = "50.3.0"
+version = "52.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "815acced725d30601b397e39958e0e55630e0a10d66ef7769c14ae6597298bb0"
+checksum = "ae7a8abc0b4fe624000972a9b145b30b7f1b680bffaa950ea53f78d9b21c27c3"
 dependencies = [
  "arrow",
  "datafusion-common",
@@ -2601,23 +2226,26 @@ dependencies = [
 
 [[package]]
 name = "datafusion-physical-expr-common"
-version = "50.3.0"
+version = "52.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6652fe7b5bf87e85ed175f571745305565da2c0b599d98e697bcbedc7baa47c3"
+checksum = "147253ca3e6b9d59c162de64c02800973018660e13340dd1886dd038d17ac429"
 dependencies = [
  "ahash",
  "arrow",
+ "chrono",
  "datafusion-common",
  "datafusion-expr-common",
- "hashbrown 0.14.5",
+ "hashbrown 0.16.1",
+ "indexmap 2.14.0",
  "itertools 0.14.0",
+ "parking_lot",
 ]
 
 [[package]]
 name = "datafusion-physical-optimizer"
-version = "50.3.0"
+version = "52.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49b7d623eb6162a3332b564a0907ba00895c505d101b99af78345f1acf929b5c"
+checksum = "689156bb2282107b6239db8d7ef44b4dab10a9b33d3491a0c74acac5e4fedd72"
 dependencies = [
  "arrow",
  "datafusion-common",
@@ -2629,34 +2257,32 @@ dependencies = [
  "datafusion-physical-plan",
  "datafusion-pruning",
  "itertools 0.14.0",
- "log",
- "recursive",
 ]
 
 [[package]]
 name = "datafusion-physical-plan"
-version = "50.3.0"
+version = "52.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2f7f778a1a838dec124efb96eae6144237d546945587557c9e6936b3414558c"
+checksum = "68253dc0ee5330aa558b2549c9b0da5af9fc17d753ae73022939014ad616fc28"
 dependencies = [
  "ahash",
  "arrow",
  "arrow-ord",
  "arrow-schema",
  "async-trait",
- "chrono",
  "datafusion-common",
  "datafusion-common-runtime",
  "datafusion-execution",
  "datafusion-expr",
+ "datafusion-functions",
  "datafusion-functions-aggregate-common",
  "datafusion-functions-window-common",
  "datafusion-physical-expr",
  "datafusion-physical-expr-common",
  "futures",
  "half",
- "hashbrown 0.14.5",
- "indexmap 2.13.0",
+ "hashbrown 0.16.1",
+ "indexmap 2.14.0",
  "itertools 0.14.0",
  "log",
  "parking_lot",
@@ -2666,12 +2292,11 @@ dependencies = [
 
 [[package]]
 name = "datafusion-pruning"
-version = "50.3.0"
+version = "52.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd1e59e2ca14fe3c30f141600b10ad8815e2856caa59ebbd0e3e07cd3d127a65"
+checksum = "0fcad240a54d0b1d3e8f668398900260a53122d522b2102ab57218590decacd6"
 dependencies = [
  "arrow",
- "arrow-schema",
  "datafusion-common",
  "datafusion-datasource",
  "datafusion-expr-common",
@@ -2684,45 +2309,77 @@ dependencies = [
 
 [[package]]
 name = "datafusion-session"
-version = "50.3.0"
+version = "52.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21ef8e2745583619bd7a49474e8f45fbe98ebb31a133f27802217125a7b3d58d"
+checksum = "f58e83a68bb67007a8fcbf005c44cefe441270c7ee7f6dee10c0e0109b556f6d"
 dependencies = [
- "arrow",
  "async-trait",
- "dashmap",
  "datafusion-common",
- "datafusion-common-runtime",
  "datafusion-execution",
  "datafusion-expr",
- "datafusion-physical-expr",
  "datafusion-physical-plan",
- "datafusion-sql",
- "futures",
- "itertools 0.14.0",
- "log",
- "object_store",
  "parking_lot",
- "tokio",
 ]
 
 [[package]]
 name = "datafusion-sql"
-version = "50.3.0"
+version = "52.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89abd9868770386fede29e5a4b14f49c0bf48d652c3b9d7a8a0332329b87d50b"
+checksum = "be53e9eb55db0fbb8980bb6d87f2435b0524acf4c718ed54a57cabbb299b2ab3"
 dependencies = [
  "arrow",
  "bigdecimal",
+ "chrono",
  "datafusion-common",
  "datafusion-expr",
- "indexmap 2.13.0",
+ "indexmap 2.14.0",
  "log",
- "recursive",
  "regex",
  "sqlparser",
 ]
 
+[[package]]
+name = "db4-graph"
+version = "0.18.0"
+dependencies = [
+ "db4-storage",
+ "raphtory-api",
+ "raphtory-core",
+ "rayon",
+]
+
+[[package]]
+name = "db4-storage"
+version = "0.18.0"
+dependencies = [
+ "arrow-array",
+ "arrow-schema",
+ "bigdecimal",
+ "boxcar",
+ "chrono",
+ "clap",
+ "dashmap",
+ "either",
+ "iter-enum",
+ "itertools 0.13.0",
+ "lock_api",
+ "once_cell",
+ "parking_lot",
+ "parquet",
+ "proptest",
+ "raphtory-api",
+ "raphtory-api-macros",
+ "raphtory-core",
+ "rayon",
+ "serde",
+ "serde_json",
+ "tempfile",
+ "test-log",
+ "thiserror 2.0.18",
+ "tinyvec",
+ "tracing",
+]
+
 [[package]]
 name = "deadpool"
 version = "0.9.5"
@@ -2764,9 +2421,9 @@ dependencies = [
 
 [[package]]
 name = "deflate64"
-version = "0.1.10"
+version = "0.1.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26bf8fc351c5ed29b5c2f0cbbac1b209b74f60ecd62e675a998df72c49af5204"
+checksum = "ac6b926516df9c60bfa16e107b21086399f8285a44ca9711344b9e553c5146e2"
 
 [[package]]
 name = "delegate"
@@ -2786,15 +2443,13 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb"
 dependencies = [
  "const-oid",
- "pem-rfc7468",
- "zeroize",
 ]
 
 [[package]]
 name = "deranged"
-version = "0.5.5"
+version = "0.5.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ececcb659e7ba858fb4f10388c250a7252eb0a27373f1a72b8748afdd248e587"
+checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c"
 dependencies = [
  "powerfmt",
  "serde_core",
@@ -2808,7 +2463,7 @@ checksum = "1e567bd82dcff979e4b03460c307b3cdc9e96fde3d73bed1496d2bc75d9dd62a"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -2829,7 +2484,7 @@ dependencies = [
  "darling 0.20.11",
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -2839,18 +2494,39 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ab63b0e2bf4d5928aff72e83a7dace85d7bba5fe12dcc3c5a572d78caffd3f3c"
 dependencies = [
  "derive_builder_core",
- "syn 2.0.114",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "derive_more"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d751e9e49156b02b44f9c1815bcb94b984cdcc4396ecc32521c739452808b134"
+dependencies = [
+ "derive_more-impl",
+]
+
+[[package]]
+name = "derive_more-impl"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "799a97264921d8623a957f6c3b9011f3b5492f557bbb7a5a19b7fa6d06ba8dcb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "rustc_version",
+ "syn 2.0.117",
 ]
 
 [[package]]
 name = "derive_utils"
-version = "0.15.0"
+version = "0.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ccfae181bab5ab6c5478b2ccb69e4c68a02f8c3ec72f6616bfec9dbc599d2ee0"
+checksum = "362f47930db19fe7735f527e6595e4900316b893ebf6d48ad3d31be928d57dd6"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -2872,7 +2548,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
 dependencies = [
  "block-buffer",
- "const-oid",
  "crypto-common",
  "subtle",
 ]
@@ -2898,6 +2573,12 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "disjoint-sets"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ccbbca7d6a247007ca2535c616d4bb4a5fcad176ef0218671f96b88c52c3d34"
+
 [[package]]
 name = "display-error-chain"
 version = "0.2.2"
@@ -2912,7 +2593,7 @@ checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -2924,6 +2605,15 @@ dependencies = [
  "const-random",
 ]
 
+[[package]]
+name = "document-features"
+version = "0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4b8a88685455ed29a21542a33abd9cb6510b6b129abadabdcef0f4c55bc8f61"
+dependencies = [
+ "litrs",
+]
+
 [[package]]
 name = "dotenv"
 version = "0.15.0"
@@ -2966,8 +2656,7 @@ checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555"
 [[package]]
 name = "dynamic-graphql"
 version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0466a5cdd914efd439f0904a84a17506ec4757f4abf35f9e46f3f314ee13fe75"
+source = "git+https://github.com/miratepuffin/dynamic-graphql?branch=add-arg-descriptions#69a07c5fe3c16b4baf76f676c96cde5865cae1de"
 dependencies = [
  "async-graphql",
  "dynamic-graphql-derive",
@@ -2977,16 +2666,15 @@ dependencies = [
 [[package]]
 name = "dynamic-graphql-derive"
 version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c6027c3698e530bf88b37a618a05fd7a5e761dc2777771d5757ff07103f66189"
+source = "git+https://github.com/miratepuffin/dynamic-graphql?branch=add-arg-descriptions#69a07c5fe3c16b4baf76f676c96cde5865cae1de"
 dependencies = [
  "Inflector",
  "darling 0.20.11",
  "proc-macro-crate",
  "proc-macro2",
  "quote",
- "syn 2.0.114",
- "thiserror 2.0.17",
+ "syn 2.0.117",
+ "thiserror 2.0.18",
 ]
 
 [[package]]
@@ -2995,6 +2683,12 @@ version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
 
+[[package]]
+name = "encode_unicode"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0"
+
 [[package]]
 name = "encoding_rs"
 version = "0.8.35"
@@ -3004,14 +2698,45 @@ dependencies = [
  "cfg-if",
 ]
 
+[[package]]
+name = "endian-type"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c34f04666d835ff5d62e058c3995147c06f42fe86ff053337632bca83e42702d"
+
+[[package]]
+name = "env_filter"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32e90c2accc4b07a8456ea0debdc2e7587bdd890680d71173a15d4ae604f6eef"
+dependencies = [
+ "log",
+ "regex",
+]
+
 [[package]]
 name = "env_logger"
-version = "0.8.4"
+version = "0.10.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a19187fea3ac7e84da7dacf48de0c45d63c6a76f9490dae389aead16c243fce3"
+checksum = "4cd405aab171cb85d6735e5c8d9db038c17d3ca007a4d2c25f337935c3d90580"
 dependencies = [
+ "humantime",
+ "is-terminal",
  "log",
  "regex",
+ "termcolor",
+]
+
+[[package]]
+name = "env_logger"
+version = "0.11.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0621c04f2196ac3f488dd583365b9c09be011a4ab8b9f37248ffcc8f6198b56a"
+dependencies = [
+ "anstream",
+ "anstyle",
+ "env_filter",
+ "log",
 ]
 
 [[package]]
@@ -3030,6 +2755,12 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "error-code"
+version = "3.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dea2df4cf52843e0452895c455a1a2cfbb842a1e7329671acf418fdc53ed4c59"
+
 [[package]]
 name = "ethnum"
 version = "1.5.2"
@@ -3102,15 +2833,26 @@ checksum = "9afc2bd4d5a73106dd53d10d73d3401c2f32730ba2c0b93ddb888a8983680471"
 
 [[package]]
 name = "fastrand"
-version = "2.3.0"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6"
+
+[[package]]
+name = "fd-lock"
+version = "4.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
+checksum = "0ce92ff622d6dadf7349484f42c93271a0d49b7cc4d466a936405bacbe10aa78"
+dependencies = [
+ "cfg-if",
+ "rustix 1.1.4",
+ "windows-sys 0.59.0",
+]
 
 [[package]]
 name = "find-msvc-tools"
-version = "0.1.7"
+version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f449e6c6c08c865631d4890cfacf252b3d396c9bcc83adb6623cdb02a8336c41"
+checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
 
 [[package]]
 name = "fixedbitset"
@@ -3130,9 +2872,9 @@ dependencies = [
 
 [[package]]
 name = "flate2"
-version = "1.1.8"
+version = "1.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b375d6465b98090a5f25b1c7703f3859783755aa9a80433b36e0379a3ec2f369"
+checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c"
 dependencies = [
  "crc32fast",
  "miniz_oxide",
@@ -3151,6 +2893,12 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
 
+[[package]]
+name = "foldhash"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
+
 [[package]]
 name = "form_urlencoded"
 version = "1.2.2"
@@ -3178,12 +2926,12 @@ checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"
 
 [[package]]
 name = "fsst"
-version = "0.39.0"
+version = "4.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d2475ce218217196b161b025598f77e2b405d5e729f7c37bfff145f5df00a41"
+checksum = "2195cc7f87e84bd695586137de99605e7e9579b26ec5e01b82960ddb4d0922f2"
 dependencies = [
  "arrow-array",
- "rand 0.9.2",
+ "rand 0.9.4",
 ]
 
 [[package]]
@@ -3203,9 +2951,9 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
 
 [[package]]
 name = "futures"
-version = "0.3.31"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876"
+checksum = "8b147ee9d1f6d097cef9ce628cd2ee62288d963e16fb287bd9286455b241382d"
 dependencies = [
  "futures-channel",
  "futures-core",
@@ -3218,9 +2966,9 @@ dependencies = [
 
 [[package]]
 name = "futures-channel"
-version = "0.3.31"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10"
+checksum = "07bbe89c50d7a535e539b8c17bc0b49bdb77747034daa8087407d655f3f7cc1d"
 dependencies = [
  "futures-core",
  "futures-sink",
@@ -3228,15 +2976,15 @@ dependencies = [
 
 [[package]]
 name = "futures-core"
-version = "0.3.31"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
+checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d"
 
 [[package]]
 name = "futures-executor"
-version = "0.3.31"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f"
+checksum = "baf29c38818342a3b26b5b923639e7b1f4a61fc5e76102d4b1981c6dc7a7579d"
 dependencies = [
  "futures-core",
  "futures-task",
@@ -3245,9 +2993,9 @@ dependencies = [
 
 [[package]]
 name = "futures-io"
-version = "0.3.31"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
+checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718"
 
 [[package]]
 name = "futures-lite"
@@ -3261,26 +3009,26 @@ dependencies = [
 
 [[package]]
 name = "futures-macro"
-version = "0.3.31"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
+checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
 name = "futures-sink"
-version = "0.3.31"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7"
+checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893"
 
 [[package]]
 name = "futures-task"
-version = "0.3.31"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
+checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393"
 
 [[package]]
 name = "futures-timer"
@@ -3290,9 +3038,9 @@ checksum = "f288b0a4f20f9a56b5d1da57e2227c661b7b16168e2f72365f57b63326e29b24"
 
 [[package]]
 name = "futures-util"
-version = "0.3.31"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
+checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6"
 dependencies = [
  "futures-channel",
  "futures-core",
@@ -3302,7 +3050,6 @@ dependencies = [
  "futures-task",
  "memchr",
  "pin-project-lite",
- "pin-utils",
  "slab",
 ]
 
@@ -3323,9 +3070,9 @@ dependencies = [
 
 [[package]]
 name = "generic-array"
-version = "0.14.7"
+version = "0.14.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+checksum = "4bb6743198531e02858aeaea5398fcc883e71851fcbcb5a2f773e2fb6cb1edf2"
 dependencies = [
  "typenum",
  "version_check",
@@ -3353,11 +3100,25 @@ dependencies = [
  "cfg-if",
  "js-sys",
  "libc",
- "r-efi",
+ "r-efi 5.3.0",
  "wasip2",
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "getrandom"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi 6.0.0",
+ "rand_core 0.10.1",
+ "wasip2",
+ "wasip3",
+]
+
 [[package]]
 name = "glam"
 version = "0.29.3"
@@ -3370,37 +3131,6 @@ version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
 
-[[package]]
-name = "gloo-timers"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbb143cf96099802033e0d4f4963b19fd2e0b728bcf076cd9cf7f6634f092994"
-dependencies = [
- "futures-channel",
- "futures-core",
- "js-sys",
- "wasm-bindgen",
-]
-
-[[package]]
-name = "h2"
-version = "0.3.27"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0beca50380b1fc32983fc1cb4587bfa4bb9e78fc259aad4a0032d2080309222d"
-dependencies = [
- "bytes",
- "fnv",
- "futures-core",
- "futures-sink",
- "futures-util",
- "http 0.2.12",
- "indexmap 2.13.0",
- "slab",
- "tokio",
- "tokio-util",
- "tracing",
-]
-
 [[package]]
 name = "h2"
 version = "0.4.13"
@@ -3412,8 +3142,8 @@ dependencies = [
  "fnv",
  "futures-core",
  "futures-sink",
- "http 1.4.0",
- "indexmap 2.13.0",
+ "http",
+ "indexmap 2.14.0",
  "slab",
  "tokio",
  "tokio-util",
@@ -3446,7 +3176,7 @@ dependencies = [
  "pest_derive",
  "serde",
  "serde_json",
- "thiserror 2.0.17",
+ "thiserror 2.0.18",
 ]
 
 [[package]]
@@ -3473,7 +3203,7 @@ checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
 dependencies = [
  "allocator-api2",
  "equivalent",
- "foldhash",
+ "foldhash 0.1.5",
 ]
 
 [[package]]
@@ -3481,6 +3211,17 @@ name = "hashbrown"
 version = "0.16.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+dependencies = [
+ "allocator-api2",
+ "equivalent",
+ "foldhash 0.2.0",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4f467dd6dccf739c208452f8014c75c18bb8301b050ad1cfb27153803edb0f51"
 
 [[package]]
 name = "hashlink"
@@ -3500,7 +3241,7 @@ dependencies = [
  "base64 0.22.1",
  "bytes",
  "headers-core",
- "http 1.4.0",
+ "http",
  "httpdate",
  "mime",
  "sha1",
@@ -3512,7 +3253,7 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "54b4a22553d4242c49fddb9ba998a99962b5cc6f22cb5a3482bec22522403ce4"
 dependencies = [
- "http 1.4.0",
+ "http",
 ]
 
 [[package]]
@@ -3529,9 +3270,9 @@ checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
 [[package]]
 name = "heed"
-version = "0.22.0"
+version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a56c94661ddfb51aa9cdfbf102cfcc340aa69267f95ebccc4af08d7c530d393"
+checksum = "ad82d6598ccf1dac15c8b758a1bd282b755b6776be600429176757190a1b0202"
 dependencies = [
  "bitflags",
  "byteorder",
@@ -3558,7 +3299,7 @@ version = "0.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "13c255bdf46e07fb840d120a36dcc81f385140d7191c76a7391672675c01a55d"
 dependencies = [
- "bincode",
+ "bincode 1.3.3",
  "byteorder",
  "heed-traits",
  "serde",
@@ -3601,17 +3342,6 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e9025058dae765dee5070ec375f591e2ba14638c63feff74f13805a72e523163"
 
-[[package]]
-name = "http"
-version = "0.2.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1"
-dependencies = [
- "bytes",
- "fnv",
- "itoa",
-]
-
 [[package]]
 name = "http"
 version = "1.4.0"
@@ -3622,17 +3352,6 @@ dependencies = [
  "itoa",
 ]
 
-[[package]]
-name = "http-body"
-version = "0.4.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ceab25649e9960c0311ea418d17bee82c0dcec1bd053b5f9a66e265a693bed2"
-dependencies = [
- "bytes",
- "http 0.2.12",
- "pin-project-lite",
-]
-
 [[package]]
 name = "http-body"
 version = "1.0.1"
@@ -3640,7 +3359,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184"
 dependencies = [
  "bytes",
- "http 1.4.0",
+ "http",
 ]
 
 [[package]]
@@ -3651,8 +3370,8 @@ checksum = "b021d93e26becf5dc7e1b75b1bed1fd93124b374ceb73f43d4d4eafec896a64a"
 dependencies = [
  "bytes",
  "futures-core",
- "http 1.4.0",
- "http-body 1.0.1",
+ "http",
+ "http-body",
  "pin-project-lite",
 ]
 
@@ -3676,46 +3395,21 @@ checksum = "135b12329e5e3ce057a9f972339ea52bc954fe1e9358ef27f95e89716fbc5424"
 
 [[package]]
 name = "hyper"
-version = "0.14.32"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41dfc780fdec9373c01bae43289ea34c972e40ee3c9f6b3c8801a35f35586ce7"
-dependencies = [
- "bytes",
- "futures-channel",
- "futures-core",
- "futures-util",
- "h2 0.3.27",
- "http 0.2.12",
- "http-body 0.4.6",
- "httparse",
- "httpdate",
- "itoa",
- "pin-project-lite",
- "socket2 0.5.10",
- "tokio",
- "tower-service",
- "tracing",
- "want",
-]
-
-[[package]]
-name = "hyper"
-version = "1.8.1"
+version = "1.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ab2d4f250c3d7b1c9fcdff1cece94ea4e2dfbec68614f7b87cb205f24ca9d11"
+checksum = "6299f016b246a94207e63da54dbe807655bf9e00044f73ded42c3ac5305fbcca"
 dependencies = [
  "atomic-waker",
  "bytes",
  "futures-channel",
  "futures-core",
- "h2 0.4.13",
- "http 1.4.0",
- "http-body 1.0.1",
+ "h2",
+ "http",
+ "http-body",
  "httparse",
  "httpdate",
  "itoa",
  "pin-project-lite",
- "pin-utils",
  "smallvec",
  "tokio",
  "want",
@@ -3723,35 +3417,19 @@ dependencies = [
 
 [[package]]
 name = "hyper-rustls"
-version = "0.24.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590"
-dependencies = [
- "futures-util",
- "http 0.2.12",
- "hyper 0.14.32",
- "log",
- "rustls 0.21.12",
- "tokio",
- "tokio-rustls 0.24.1",
-]
-
-[[package]]
-name = "hyper-rustls"
-version = "0.27.7"
+version = "0.27.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3c93eb611681b207e1fe55d5a71ecf91572ec8a6705cdb6857f7d8d5242cf58"
+checksum = "33ca68d021ef39cf6463ab54c1d0f5daf03377b70561305bb89a8f83aab66e0f"
 dependencies = [
- "http 1.4.0",
- "hyper 1.8.1",
+ "http",
+ "hyper",
  "hyper-util",
- "rustls 0.23.36",
+ "rustls",
  "rustls-native-certs 0.8.3",
- "rustls-pki-types",
  "tokio",
- "tokio-rustls 0.26.4",
+ "tokio-rustls",
  "tower-service",
- "webpki-roots 1.0.5",
+ "webpki-roots 1.0.6",
 ]
 
 [[package]]
@@ -3760,7 +3438,7 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2b90d566bffbce6a75bd8b09a05aa8c2cb1fabb6cb348f8840c9e4c90a0d83b0"
 dependencies = [
- "hyper 1.8.1",
+ "hyper",
  "hyper-util",
  "pin-project-lite",
  "tokio",
@@ -3769,23 +3447,22 @@ dependencies = [
 
 [[package]]
 name = "hyper-util"
-version = "0.1.19"
+version = "0.1.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "727805d60e7938b76b826a6ef209eb70eaa1812794f9424d4a4e2d740662df5f"
+checksum = "96547c2556ec9d12fb1578c4eaf448b04993e7fb79cbaad930a656880a6bdfa0"
 dependencies = [
  "base64 0.22.1",
  "bytes",
  "futures-channel",
- "futures-core",
  "futures-util",
- "http 1.4.0",
- "http-body 1.0.1",
- "hyper 1.8.1",
+ "http",
+ "http-body",
+ "hyper",
  "ipnet",
  "libc",
  "percent-encoding",
  "pin-project-lite",
- "socket2 0.6.1",
+ "socket2 0.6.3",
  "tokio",
  "tower-service",
  "tracing",
@@ -3802,9 +3479,9 @@ dependencies = [
 
 [[package]]
 name = "iana-time-zone"
-version = "0.1.64"
+version = "0.1.65"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33e57f83510bb73707521ebaffa789ec8caf86f9657cad665b092b581d40e9fb"
+checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470"
 dependencies = [
  "android_system_properties",
  "core-foundation-sys",
@@ -3826,12 +3503,13 @@ dependencies = [
 
 [[package]]
 name = "icu_collections"
-version = "2.1.1"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c6b649701667bbe825c3b7e6388cb521c23d88644678e83c0c4d0a621a34b43"
+checksum = "2984d1cd16c883d7935b9e07e44071dca8d917fd52ecc02c04d5fa0b5a3f191c"
 dependencies = [
  "displaydoc",
  "potential_utf",
+ "utf8_iter",
  "yoke",
  "zerofrom",
  "zerovec",
@@ -3839,9 +3517,9 @@ dependencies = [
 
 [[package]]
 name = "icu_locale_core"
-version = "2.1.1"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "edba7861004dd3714265b4db54a3c390e880ab658fec5f7db895fae2046b5bb6"
+checksum = "92219b62b3e2b4d88ac5119f8904c10f8f61bf7e95b640d25ba3075e6cac2c29"
 dependencies = [
  "displaydoc",
  "litemap",
@@ -3852,9 +3530,9 @@ dependencies = [
 
 [[package]]
 name = "icu_normalizer"
-version = "2.1.1"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f6c8828b67bf8908d82127b2054ea1b4427ff0230ee9141c54251934ab1b599"
+checksum = "c56e5ee99d6e3d33bd91c5d85458b6005a22140021cc324cea84dd0e72cff3b4"
 dependencies = [
  "icu_collections",
  "icu_normalizer_data",
@@ -3866,15 +3544,15 @@ dependencies = [
 
 [[package]]
 name = "icu_normalizer_data"
-version = "2.1.1"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7aedcccd01fc5fe81e6b489c15b247b8b0690feb23304303a9e560f37efc560a"
+checksum = "da3be0ae77ea334f4da67c12f149704f19f81d1adf7c51cf482943e84a2bad38"
 
 [[package]]
 name = "icu_properties"
-version = "2.1.2"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "020bfc02fe870ec3a66d93e677ccca0562506e5872c650f893269e08615d74ec"
+checksum = "bee3b67d0ea5c2cca5003417989af8996f8604e34fb9ddf96208a033901e70de"
 dependencies = [
  "icu_collections",
  "icu_locale_core",
@@ -3886,15 +3564,15 @@ dependencies = [
 
 [[package]]
 name = "icu_properties_data"
-version = "2.1.2"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "616c294cf8d725c6afcd8f55abc17c56464ef6211f9ed59cccffe534129c77af"
+checksum = "8e2bbb201e0c04f7b4b3e14382af113e17ba4f63e2c9d2ee626b720cbce54a14"
 
 [[package]]
 name = "icu_provider"
-version = "2.1.1"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85962cf0ce02e1e0a629cc34e7ca3e373ce20dda4c4d7294bbd0bf1fdb59e614"
+checksum = "139c4cf31c8b5f33d7e199446eff9c1e02decfc2f0eec2c8d71f65befa45b421"
 dependencies = [
  "displaydoc",
  "icu_locale_core",
@@ -3905,6 +3583,12 @@ dependencies = [
  "zerovec",
 ]
 
+[[package]]
+name = "id-arena"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
+
 [[package]]
 name = "ident_case"
 version = "1.0.1"
@@ -3945,12 +3629,12 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.13.0"
+version = "2.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017"
+checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9"
 dependencies = [
  "equivalent",
- "hashbrown 0.16.1",
+ "hashbrown 0.17.0",
  "rayon",
  "serde",
  "serde_core",
@@ -3971,10 +3655,22 @@ version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"
 dependencies = [
- "block-padding",
  "generic-array",
 ]
 
+[[package]]
+name = "insta"
+version = "1.47.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b4a6248eb93a4401ed2f37dfe8ea592d3cf05b7cf4f8efa867b6895af7e094e"
+dependencies = [
+ "console",
+ "once_cell",
+ "serde",
+ "similar",
+ "tempfile",
+]
+
 [[package]]
 name = "instant"
 version = "0.1.13"
@@ -3995,24 +3691,24 @@ checksum = "8bb03732005da905c88227371639bf1ad885cc712789c011c31c5fb3ab3ccf02"
 
 [[package]]
 name = "inventory"
-version = "0.3.21"
+version = "0.3.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc61209c082fbeb19919bee74b176221b27223e27b65d781eb91af24eb1fb46e"
+checksum = "a4f0c30c76f2f4ccee3fe55a2435f691ca00c0e4bd87abe4f4a851b1d4dac39b"
 dependencies = [
  "rustversion",
 ]
 
 [[package]]
 name = "ipnet"
-version = "2.11.0"
+version = "2.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "469fb0b9cefa57e3ef31275ee7cacb78f2fdca44e4765491884a2b119d4eb130"
+checksum = "d98f6fed1fde3f8c21bc40a1abb88dd75e67924f9cffc3ef95607bad8017f8e2"
 
 [[package]]
 name = "iri-string"
-version = "0.7.10"
+version = "0.7.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c91338f0783edbd6195decb37bae672fd3b165faffb89bf7b9e6942f8b1a731a"
+checksum = "25e659a4bb38e810ebc252e53b5814ff908a8c58c2a9ce2fae1bbec24cbf4e20"
 dependencies = [
  "memchr",
  "serde",
@@ -4037,9 +3733,9 @@ checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
 
 [[package]]
 name = "iter-enum"
-version = "1.2.0"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c52f2d5e063459674b4735f21870dd911e0d96dbfebb984650068195c2df838"
+checksum = "d9e701a443ecfdedddeea9b7975a1875c933f4001f12defa8a7a53e959611308"
 dependencies = [
  "derive_utils",
 ]
@@ -4091,15 +3787,15 @@ dependencies = [
 
 [[package]]
 name = "itoa"
-version = "1.0.17"
+version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
 
 [[package]]
 name = "jiff"
-version = "0.2.18"
+version = "0.2.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e67e8da4c49d6d9909fe03361f9b620f58898859f5c7aded68351e85e71ecf50"
+checksum = "1a3546dc96b6d42c5f24902af9e2538e82e39ad350b0c766eb3fbf2d8f3d8359"
 dependencies = [
  "jiff-static",
  "jiff-tzdb-platform",
@@ -4112,20 +3808,20 @@ dependencies = [
 
 [[package]]
 name = "jiff-static"
-version = "0.2.18"
+version = "0.2.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0c84ee7f197eca9a86c6fd6cb771e55eb991632f15f2bc3ca6ec838929e6e78"
+checksum = "2a8c8b344124222efd714b73bb41f8b5120b27a7cc1c75593a6ff768d9d05aa4"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
 name = "jiff-tzdb"
-version = "0.1.5"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68971ebff725b9e2ca27a601c5eb38a4c5d64422c4cbab0c535f248087eda5c2"
+checksum = "c900ef84826f1338a557697dc8fc601df9ca9af4ac137c7fb61d4c6f2dfd3076"
 
 [[package]]
 name = "jiff-tzdb-platform"
@@ -4148,10 +3844,12 @@ dependencies = [
 
 [[package]]
 name = "js-sys"
-version = "0.3.83"
+version = "0.3.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "464a3709c7f55f1f721e5389aa6ea4e3bc6aba669353300af094b29ffbdde1d8"
+checksum = "2964e92d1d9dc3364cae4d718d93f227e3abb088e747d92e0395bfdedf1c12ca"
 dependencies = [
+ "cfg-if",
+ "futures-util",
  "once_cell",
  "wasm-bindgen",
 ]
@@ -4169,9 +3867,9 @@ dependencies = [
 
 [[package]]
 name = "jsonb"
-version = "0.5.5"
+version = "0.5.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a901f06163d352fbe41c3c2ff5e08b75330a003cc941e988fb501022f5421e6"
+checksum = "eb98fb29636087c40ad0d1274d9a30c0c1e83e03ae93f6e7e89247b37fcc6953"
 dependencies = [
  "byteorder",
  "ethnum",
@@ -4180,26 +3878,11 @@ dependencies = [
  "jiff",
  "nom 8.0.0",
  "num-traits",
- "ordered-float 5.1.0",
- "rand 0.9.2",
- "ryu",
- "serde",
- "serde_json",
-]
-
-[[package]]
-name = "jsonwebtoken"
-version = "9.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a87cc7a48537badeae96744432de36f4be2b4a34a05a5ef32e9dd8a1c169dde"
-dependencies = [
- "base64 0.22.1",
- "js-sys",
- "pem",
- "ring",
+ "ordered-float 5.3.0",
+ "rand 0.9.4",
  "serde",
  "serde_json",
- "simple_asn1",
+ "zmij",
 ]
 
 [[package]]
@@ -4221,20 +3904,20 @@ dependencies = [
 
 [[package]]
 name = "kdam"
-version = "0.6.3"
+version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5740f66a8d86a086ebcacfb937070e8be6eb2f8fb45e4ae7fa428ca2a98a7b1f"
+checksum = "d847be338ef16a13f97637c062d97fb52ebe0ff3b77fa18456d5ed366317e4f7"
 dependencies = [
  "pyo3",
  "terminal_size",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "lance"
-version = "0.39.0"
+version = "4.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2f0ca022d0424d991933a62d2898864cf5621873962bd84e65e7d1f023f9c36"
+checksum = "efe6c3ddd79cdfd2b7e1c23cafae52806906bc40fbd97de9e8cf2f8c7a75fc04"
 dependencies = [
  "arrow",
  "arrow-arith",
@@ -4248,11 +3931,10 @@ dependencies = [
  "async-recursion",
  "async-trait",
  "async_cell",
- "aws-credential-types",
- "aws-sdk-dynamodb",
  "byteorder",
  "bytes",
  "chrono",
+ "crossbeam-skiplist",
  "dashmap",
  "datafusion",
  "datafusion-expr",
@@ -4280,17 +3962,18 @@ dependencies = [
  "object_store",
  "permutation",
  "pin-project",
- "prost",
- "prost-types",
- "rand 0.9.2",
- "roaring",
+ "prost 0.14.3",
+ "prost-types 0.14.3",
+ "rand 0.9.4",
+ "roaring 0.11.3",
  "semver",
  "serde",
  "serde_json",
- "snafu",
+ "snafu 0.9.0",
  "tantivy 0.24.2",
  "tokio",
  "tokio-stream",
+ "tokio-util",
  "tracing",
  "url",
  "uuid",
@@ -4298,29 +3981,31 @@ dependencies = [
 
 [[package]]
 name = "lance-arrow"
-version = "0.39.0"
+version = "4.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7552f8d528775bf0ab21e1f75dcb70bdb2a828eeae58024a803b5a4655fd9a11"
+checksum = "5d9f5d95bdda2a2b790f1fb8028b5b6dcf661abeb3133a8bca0f3d24b054af87"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
  "arrow-cast",
  "arrow-data",
+ "arrow-ord",
  "arrow-schema",
  "arrow-select",
  "bytes",
+ "futures",
  "getrandom 0.2.17",
  "half",
  "jsonb",
  "num-traits",
- "rand 0.9.2",
+ "rand 0.9.4",
 ]
 
 [[package]]
 name = "lance-bitpacking"
-version = "0.39.0"
+version = "4.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2ea14583cc6fa0bb190bcc2d3bc364b0aa545b345702976025f810e4740e8ce"
+checksum = "f827d6ab9f8f337a9509d5ad66a12f3314db8713868260521c344ef6135eb4e4"
 dependencies = [
  "arrayref",
  "paste",
@@ -4329,9 +4014,9 @@ dependencies = [
 
 [[package]]
 name = "lance-core"
-version = "0.39.0"
+version = "4.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69c752dedd207384892006c40930f898d6634e05e3d489e89763abfe4b9307e7"
+checksum = "0f1e25df6a79bf72ee6bcde0851f19b1cd36c5848c1b7db83340882d3c9fdecb"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -4344,6 +4029,7 @@ dependencies = [
  "datafusion-sql",
  "deepsize",
  "futures",
+ "itertools 0.13.0",
  "lance-arrow",
  "libc",
  "log",
@@ -4352,11 +4038,11 @@ dependencies = [
  "num_cpus",
  "object_store",
  "pin-project",
- "prost",
- "rand 0.9.2",
- "roaring",
+ "prost 0.14.3",
+ "rand 0.9.4",
+ "roaring 0.11.3",
  "serde_json",
- "snafu",
+ "snafu 0.9.0",
  "tempfile",
  "tokio",
  "tokio-stream",
@@ -4367,9 +4053,9 @@ dependencies = [
 
 [[package]]
 name = "lance-datafusion"
-version = "0.39.0"
+version = "4.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21e1e98ca6e5cd337bdda2d9fb66063f295c0c2852d2bc6831366fea833ee608"
+checksum = "93146de8ae720cb90edef81c2f2d0a1b065fc2f23ecff2419546f389b0fa70a4"
 dependencies = [
  "arrow",
  "arrow-array",
@@ -4390,17 +4076,18 @@ dependencies = [
  "lance-datagen",
  "log",
  "pin-project",
- "prost",
- "snafu",
+ "prost 0.14.3",
+ "prost-build 0.14.3",
+ "snafu 0.9.0",
  "tokio",
  "tracing",
 ]
 
 [[package]]
 name = "lance-datagen"
-version = "0.39.0"
+version = "4.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "483c643fc2806ed1a2766edf4d180511bbd1d549bcc60373e33f4785c6185891"
+checksum = "ccec8ce4d8e0a87a99c431dab2364398029f2ffb649c1a693c60c79e05ed30dd"
 dependencies = [
  "arrow",
  "arrow-array",
@@ -4410,16 +4097,17 @@ dependencies = [
  "futures",
  "half",
  "hex",
- "rand 0.9.2",
+ "rand 0.9.4",
+ "rand_distr 0.5.1",
  "rand_xoshiro",
  "random_word",
 ]
 
 [[package]]
 name = "lance-encoding"
-version = "0.39.0"
+version = "4.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a199d1fa3487529c5ffc433fbd1721231330b9350c2ff9b0c7b7dbdb98f0806a"
+checksum = "5c1aec0bbbac6bce829bc10f1ba066258126100596c375fb71908ecf11c2c2a5"
 dependencies = [
  "arrow-arith",
  "arrow-array",
@@ -4442,11 +4130,11 @@ dependencies = [
  "log",
  "lz4",
  "num-traits",
- "prost",
- "prost-build",
- "prost-types",
- "rand 0.9.2",
- "snafu",
+ "prost 0.14.3",
+ "prost-build 0.14.3",
+ "prost-types 0.14.3",
+ "rand 0.9.4",
+ "snafu 0.9.0",
  "strum 0.26.3",
  "tokio",
  "tracing",
@@ -4456,9 +4144,9 @@ dependencies = [
 
 [[package]]
 name = "lance-file"
-version = "0.39.0"
+version = "4.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b57def2279465232cf5a8cd996300c632442e368745768bbed661c7f0a35334b"
+checksum = "14a8c548804f5b17486dc2d3282356ed1957095a852780283bc401fdd69e9075"
 dependencies = [
  "arrow-arith",
  "arrow-array",
@@ -4480,19 +4168,19 @@ dependencies = [
  "log",
  "num-traits",
  "object_store",
- "prost",
- "prost-build",
- "prost-types",
- "snafu",
+ "prost 0.14.3",
+ "prost-build 0.14.3",
+ "prost-types 0.14.3",
+ "snafu 0.9.0",
  "tokio",
  "tracing",
 ]
 
 [[package]]
 name = "lance-index"
-version = "0.39.0"
+version = "4.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a75938c61e986aef8c615dc44c92e4c19e393160a59e2b57402ccfe08c5e63af"
+checksum = "2da212f0090ea59f79ac3686660f596520c167fe1cb5f408900cf71d215f0e03"
 dependencies = [
  "arrow",
  "arrow-arith",
@@ -4506,6 +4194,7 @@ dependencies = [
  "bitpacking",
  "bitvec",
  "bytes",
+ "chrono",
  "crossbeam-queue",
  "datafusion",
  "datafusion-common",
@@ -4530,19 +4219,21 @@ dependencies = [
  "lance-table",
  "libm",
  "log",
- "ndarray",
+ "ndarray 0.16.1",
  "num-traits",
  "object_store",
- "prost",
- "prost-build",
- "prost-types",
- "rand 0.9.2",
+ "prost 0.14.3",
+ "prost-build 0.14.3",
+ "prost-types 0.14.3",
+ "rand 0.9.4",
  "rand_distr 0.5.1",
+ "rangemap",
  "rayon",
- "roaring",
+ "roaring 0.11.3",
  "serde",
  "serde_json",
- "snafu",
+ "smallvec",
+ "snafu 0.9.0",
  "tantivy 0.24.2",
  "tempfile",
  "tokio",
@@ -4553,9 +4244,9 @@ dependencies = [
 
 [[package]]
 name = "lance-io"
-version = "0.39.0"
+version = "4.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa6c3b5b28570d6c951206c5b043f1b35c936928af14fca6f2ac25b0097e4c32"
+checksum = "41d958eb4b56f03bbe0f5f85eb2b4e9657882812297b6f711f201ffc995f259f"
 dependencies = [
  "arrow",
  "arrow-arith",
@@ -4567,27 +4258,24 @@ dependencies = [
  "arrow-select",
  "async-recursion",
  "async-trait",
- "aws-config",
- "aws-credential-types",
  "byteorder",
  "bytes",
  "chrono",
  "deepsize",
  "futures",
+ "http",
  "lance-arrow",
  "lance-core",
  "lance-namespace",
  "log",
  "object_store",
- "object_store_opendal",
- "opendal",
  "path_abs",
  "pin-project",
- "prost",
- "rand 0.9.2",
+ "prost 0.14.3",
+ "rand 0.9.4",
  "serde",
- "shellexpand",
- "snafu",
+ "snafu 0.9.0",
+ "tempfile",
  "tokio",
  "tracing",
  "url",
@@ -4595,9 +4283,9 @@ dependencies = [
 
 [[package]]
 name = "lance-linalg"
-version = "0.39.0"
+version = "4.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b3cbc7e85a89ff9cb3a4627559dea3fd1c1fb16c0d8bc46ede75eefef51eec06"
+checksum = "0285b70da35def7ed95e150fae1d5308089554e1290470403ed3c50cb235bc5e"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -4608,50 +4296,57 @@ dependencies = [
  "lance-arrow",
  "lance-core",
  "num-traits",
- "rand 0.9.2",
+ "rand 0.9.4",
 ]
 
 [[package]]
 name = "lance-namespace"
-version = "0.39.0"
+version = "4.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "897dd6726816515bb70a698ce7cda44670dca5761637696d7905b45f405a8cd9"
+checksum = "5f78e2a828b654e062a495462c6e3eb4fcf0e7e907d761b8f217fc09ccd3ceac"
 dependencies = [
  "arrow",
  "async-trait",
  "bytes",
  "lance-core",
  "lance-namespace-reqwest-client",
- "snafu",
+ "serde",
+ "snafu 0.9.0",
 ]
 
 [[package]]
 name = "lance-namespace-impls"
-version = "0.39.0"
+version = "4.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e3cfcd3ba369de2719abf6fb6233f69cda639eb5cbcb328487a790e745ab988"
+checksum = "a2392314f3da38f00d166295e44244208a65ccfc256e274fa8631849fc3f4d94"
 dependencies = [
  "arrow",
  "arrow-ipc",
  "arrow-schema",
  "async-trait",
  "bytes",
+ "chrono",
+ "futures",
  "lance",
  "lance-core",
+ "lance-index",
  "lance-io",
  "lance-namespace",
+ "lance-table",
+ "log",
  "object_store",
- "reqwest",
+ "rand 0.9.4",
  "serde_json",
- "snafu",
+ "snafu 0.9.0",
+ "tokio",
  "url",
 ]
 
 [[package]]
 name = "lance-namespace-reqwest-client"
-version = "0.0.18"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ea349999bcda4eea53fc05d334b3775ec314761e6a706555c777d7a29b18d19"
+checksum = "ee2e48de899e2931afb67fcddd0a08e439bf5d8b6ea2a2ed9cb8f4df669bd5cc"
 dependencies = [
  "reqwest",
  "serde",
@@ -4662,9 +4357,9 @@ dependencies = [
 
 [[package]]
 name = "lance-table"
-version = "0.39.0"
+version = "4.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8facc13760ba034b6c38767b16adba85e44cbcbea8124dc0c63c43865c60630"
+checksum = "3df9c4adca3eb2074b3850432a9fb34248a3d90c3d6427d158b13ff9355664ee"
 dependencies = [
  "arrow",
  "arrow-array",
@@ -4672,8 +4367,6 @@ dependencies = [
  "arrow-ipc",
  "arrow-schema",
  "async-trait",
- "aws-credential-types",
- "aws-sdk-dynamodb",
  "byteorder",
  "bytes",
  "chrono",
@@ -4685,16 +4378,16 @@ dependencies = [
  "lance-io",
  "log",
  "object_store",
- "prost",
- "prost-build",
- "prost-types",
- "rand 0.9.2",
+ "prost 0.14.3",
+ "prost-build 0.14.3",
+ "prost-types 0.14.3",
+ "rand 0.9.4",
  "rangemap",
- "roaring",
+ "roaring 0.11.3",
  "semver",
  "serde",
  "serde_json",
- "snafu",
+ "snafu 0.9.0",
  "tokio",
  "tracing",
  "url",
@@ -4703,22 +4396,22 @@ dependencies = [
 
 [[package]]
 name = "lance-testing"
-version = "0.39.0"
+version = "4.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b05052ef86188d6ae6339bdd9f2c5d77190e8ad1158f3dc8a42fa91bde9e5246"
+checksum = "7ed7119bdd6983718387b4ac44af873a165262ca94f181b104cd6f97912eb3bf"
 dependencies = [
  "arrow-array",
  "arrow-schema",
  "lance-arrow",
  "num-traits",
- "rand 0.9.2",
+ "rand 0.9.4",
 ]
 
 [[package]]
 name = "lancedb"
-version = "0.22.3"
+version = "0.27.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1da241266792d8caa58005a3deb06ba1388a99350d89b5c904ef6f8de5d936f"
+checksum = "ce0f4d7f739dc30608fe8b202cbb40986c2937e1a5a189f98fb06d7b8543156a"
 dependencies = [
  "ahash",
  "arrow",
@@ -4737,7 +4430,10 @@ dependencies = [
  "datafusion-common",
  "datafusion-execution",
  "datafusion-expr",
+ "datafusion-functions",
+ "datafusion-physical-expr",
  "datafusion-physical-plan",
+ "datafusion-sql",
  "futures",
  "half",
  "lance",
@@ -4760,13 +4456,13 @@ dependencies = [
  "num-traits",
  "object_store",
  "pin-project",
- "rand 0.9.2",
+ "rand 0.9.4",
  "regex",
  "semver",
  "serde",
  "serde_json",
  "serde_with",
- "snafu",
+ "snafu 0.8.9",
  "tempfile",
  "tokio",
  "url",
@@ -4778,9 +4474,12 @@ name = "lazy_static"
 version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
-dependencies = [
- "spin",
-]
+
+[[package]]
+name = "leb128fmt"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
 
 [[package]]
 name = "levenshtein_automata"
@@ -4845,31 +4544,24 @@ dependencies = [
  "lexical-util",
 ]
 
-[[package]]
-name = "libbz2-rs-sys"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c4a545a15244c7d945065b5d392b2d2d7f21526fba56ce51467b06ed445e8f7"
-
 [[package]]
 name = "libc"
-version = "0.2.180"
+version = "0.2.185"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bcc35a38544a891a5f7c865aca548a982ccb3b8650a5b06d0fd33a10283c56fc"
+checksum = "52ff2c0fe9bc6cb6b14a0592c2ff4fa9ceb83eea9db979b0487cd054946a2b8f"
 
 [[package]]
 name = "libm"
-version = "0.2.15"
+version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9fbbcab51052fe104eb5e5d351cf728d30a5be1fe14d9be8a3b097481fb97de"
+checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
 
 [[package]]
 name = "libredox"
-version = "0.1.12"
+version = "0.1.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d0b95e02c851351f877147b7deea7b1afb1df71b63aa5f8270716e0c5720616"
+checksum = "e02f3bb43d335493c96bf3fd3a321600bf6bd07ed34bc64118e9293bdffea46c"
 dependencies = [
- "bitflags",
  "libc",
 ]
 
@@ -4881,21 +4573,27 @@ checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.11.0"
+version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039"
+checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
 
 [[package]]
 name = "litemap"
-version = "0.8.1"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92daf443525c4cce67b150400bc2316076100ce0b3686209eb8cf3c31612e6f0"
+
+[[package]]
+name = "litrs"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77"
+checksum = "11d3d7f243d5c5a8b9bb5d6dd2b1602c0cb0b9db1621bafc7ed66e35ff9fe092"
 
 [[package]]
 name = "lmdb-master-sys"
-version = "0.2.5"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "864808e0b19fb6dd3b70ba94ee671b82fce17554cf80aeb0a155c65bb08027df"
+checksum = "aaeb9bd22e73bd1babffff614994b341e9b2008de7bb73bf1f7e9154f1978f8b"
 dependencies = [
  "cc",
  "doxygen-rs",
@@ -4967,9 +4665,15 @@ dependencies = [
 
 [[package]]
 name = "lz4_flex"
-version = "0.11.5"
+version = "0.11.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "373f5eceeeab7925e0c1098212f2fbc4d416adec9d35051a6ab251e824c1854a"
+
+[[package]]
+name = "lz4_flex"
+version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08ab2867e3eeeca90e844d1940eab391c9dc5228783db2ed999acbc0a9ed375a"
+checksum = "98c23545df7ecf1b16c303910a69b079e8e251d60f7dd2cc9b4177f2afaf1746"
 dependencies = [
  "twox-hash",
 ]
@@ -4997,9 +4701,9 @@ dependencies = [
 
 [[package]]
 name = "marrow"
-version = "0.2.5"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea734fcb7619dfcc47a396f7bf0c72571ccc8c18ae7236ae028d485b27424b74"
+checksum = "f5240d6977234968ff9ad254bfa73aa397fb51e41dcb22b1eb85835e9295485b"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -5075,19 +4779,25 @@ dependencies = [
 
 [[package]]
 name = "memchr"
-version = "2.7.6"
+version = "2.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
+checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
 
 [[package]]
 name = "memmap2"
-version = "0.9.9"
+version = "0.9.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "744133e4a0e0a658e1374cf3bf8e415c4052a15a111acd372764c55b4177d490"
+checksum = "714098028fe011992e1c3962653c96b2d578c4b4bce9036e15ff220319b1e0e3"
 dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "memo-map"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38d1115007560874e373613744c6fba374c17688327a71c1476d1a5954cc857b"
+
 [[package]]
 name = "memoffset"
 version = "0.9.1"
@@ -5115,18 +4825,19 @@ dependencies = [
 
 [[package]]
 name = "minijinja"
-version = "2.14.0"
+version = "2.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12ea9ac0a51fb5112607099560fdf0f90366ab088a2a9e6e8ae176794e9806aa"
+checksum = "805bfd7352166bae857ee569628b52bcd85a1cecf7810861ebceb1686b72b75d"
 dependencies = [
+ "memo-map",
  "serde",
 ]
 
 [[package]]
 name = "minijinja-contrib"
-version = "2.14.0"
+version = "2.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be6ad8bbc21c256d5f2f5494699d5d69d519b8510d672a0e43b7bfa3a56c388a"
+checksum = "45092d80391870622fcf3bd82f5d2af18f99533ea60debb4bc9db0c76f0e809a"
 dependencies = [
  "minijinja",
  "serde",
@@ -5151,9 +4862,9 @@ dependencies = [
 
 [[package]]
 name = "mio"
-version = "1.1.1"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a69bcab0ad47271a0234d9422b131806bf3968021e5dc9328caf2d4cd58557fc"
+checksum = "50b7e5b27aa02a74bac8c3f23f448f8d87ff11f92d3aac1a6ed369ee08cc56c1"
 dependencies = [
  "libc",
  "wasi",
@@ -5168,9 +4879,9 @@ checksum = "dce6dd36094cac388f119d2e9dc82dc730ef91c32a6222170d630e5414b956e6"
 
 [[package]]
 name = "moka"
-version = "0.12.12"
+version = "0.12.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3dec6bd31b08944e08b58fd99373893a6c17054d6f3ea5006cc894f4f4eee2a"
+checksum = "957228ad12042ee839f93c8f257b62b4c0ab5eaae1d4fa60de53b27c9d7c5046"
 dependencies = [
  "async-lock",
  "crossbeam-channel",
@@ -5195,7 +4906,7 @@ dependencies = [
  "bytes",
  "encoding_rs",
  "futures-util",
- "http 1.4.0",
+ "http",
  "httparse",
  "memchr",
  "mime",
@@ -5230,6 +4941,21 @@ dependencies = [
  "rawpointer",
 ]
 
+[[package]]
+name = "ndarray"
+version = "0.17.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "520080814a7a6b4a6e9070823bb24b4531daac8c4627e08ba5de8c5ef2f2752d"
+dependencies = [
+ "matrixmultiply",
+ "num-complex",
+ "num-integer",
+ "num-traits",
+ "portable-atomic",
+ "portable-atomic-util",
+ "rawpointer",
+]
+
 [[package]]
 name = "neo4rs"
 version = "0.8.0"
@@ -5253,7 +4979,7 @@ dependencies = [
  "serde",
  "thiserror 1.0.69",
  "tokio",
- "tokio-rustls 0.26.4",
+ "tokio-rustls",
  "url",
  "webpki-roots 0.26.11",
 ]
@@ -5265,7 +4991,27 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "53a0d57c55d2d1dc62a2b1d16a0a1079eb78d67c36bdf468d582ab4482ec7002"
 dependencies = [
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "nibble_vec"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77a5d83df9f36fe23f0c3648c6bbb8b0298bb5f1939c8f2704431371f4b84d43"
+dependencies = [
+ "smallvec",
+]
+
+[[package]]
+name = "nix"
+version = "0.27.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2eb04e9c688eff1c89d72b407f168cf79bb9e867a9d3323ed6c01519eb9cc053"
+dependencies = [
+ "bitflags",
+ "cfg-if",
+ "libc",
 ]
 
 [[package]]
@@ -5332,22 +5078,6 @@ dependencies = [
  "num-traits",
 ]
 
-[[package]]
-name = "num-bigint-dig"
-version = "0.8.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e661dda6640fad38e827a6d4a310ff4763082116fe217f279885c97f511bb0b7"
-dependencies = [
- "lazy_static",
- "libm",
- "num-integer",
- "num-iter",
- "num-traits",
- "rand 0.8.5",
- "smallvec",
- "zeroize",
-]
-
 [[package]]
 name = "num-complex"
 version = "0.4.6"
@@ -5359,9 +5089,9 @@ dependencies = [
 
 [[package]]
 name = "num-conv"
-version = "0.2.0"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf97ec579c3c42f953ef76dbf8d55ac91fb219dde70e49aa4a6b7d74e9919050"
+checksum = "c6673768db2d862beb9b39a78fdcb1a69439615d5794a1be50caa9bc92c81967"
 
 [[package]]
 name = "num-integer"
@@ -5431,60 +5161,37 @@ dependencies = [
 
 [[package]]
 name = "numpy"
-version = "0.25.0"
+version = "0.27.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29f1dee9aa8d3f6f8e8b9af3803006101bb3653866ef056d530d53ae68587191"
+checksum = "7aac2e6a6e4468ffa092ad43c39b81c79196c2bb773b8db4085f695efe3bba17"
 dependencies = [
  "half",
  "libc",
- "ndarray",
+ "ndarray 0.17.2",
  "num-complex",
  "num-integer",
  "num-traits",
  "pyo3",
  "pyo3-build-config",
- "rustc-hash 2.1.1",
-]
-
-[[package]]
-name = "object"
-version = "0.32.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441"
-dependencies = [
- "memchr",
+ "rustc-hash 2.1.2",
 ]
 
 [[package]]
 name = "object_store"
-version = "0.12.4"
+version = "0.12.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c1be0c6c22ec0817cdc77d3842f721a17fd30ab6965001415b5402a74e6b740"
+checksum = "fbfbfff40aeccab00ec8a910b57ca8ecf4319b335c542f2edcd19dd25a1e2a00"
 dependencies = [
  "async-trait",
- "base64 0.22.1",
  "bytes",
  "chrono",
- "form_urlencoded",
  "futures",
- "http 1.4.0",
- "http-body-util",
- "httparse",
+ "http",
  "humantime",
- "hyper 1.8.1",
  "itertools 0.14.0",
- "md-5",
  "parking_lot",
  "percent-encoding",
- "quick-xml 0.38.4",
- "rand 0.9.2",
- "reqwest",
- "ring",
- "rustls-pemfile",
- "serde",
- "serde_json",
- "serde_urlencoded",
- "thiserror 2.0.17",
+ "thiserror 2.0.18",
  "tokio",
  "tracing",
  "url",
@@ -5493,26 +5200,11 @@ dependencies = [
  "web-time",
 ]
 
-[[package]]
-name = "object_store_opendal"
-version = "0.54.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0b88fc0e0c4890c1d99e2b8c519c5db40f7d9b69a0f562ff1ad4967a4c8bbc6"
-dependencies = [
- "async-trait",
- "bytes",
- "futures",
- "object_store",
- "opendal",
- "pin-project",
- "tokio",
-]
-
 [[package]]
 name = "once_cell"
-version = "1.21.3"
+version = "1.21.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
 [[package]]
 name = "once_cell_polyfill"
@@ -5522,9 +5214,9 @@ checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
 
 [[package]]
 name = "oneshot"
-version = "0.1.11"
+version = "0.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4ce411919553d3f9fa53a0880544cda985a112117a0444d5ff1e870a893d6ea"
+checksum = "269bca4c2591a28585d6bf10d9ed0332b7d76900a1b02bec41bdc3a2cdcda107"
 
 [[package]]
 name = "oorandom"
@@ -5532,35 +5224,6 @@ version = "11.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
 
-[[package]]
-name = "opendal"
-version = "0.54.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42afda58fa2cf50914402d132cc1caacff116a85d10c72ab2082bb7c50021754"
-dependencies = [
- "anyhow",
- "backon",
- "base64 0.22.1",
- "bytes",
- "chrono",
- "crc32c",
- "futures",
- "getrandom 0.2.17",
- "http 1.4.0",
- "http-body 1.0.1",
- "log",
- "md-5",
- "percent-encoding",
- "quick-xml 0.38.4",
- "reqsign",
- "reqwest",
- "serde",
- "serde_json",
- "sha2",
- "tokio",
- "uuid",
-]
-
 [[package]]
 name = "openssl-probe"
 version = "0.1.6"
@@ -5569,9 +5232,9 @@ checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e"
 
 [[package]]
 name = "openssl-probe"
-version = "0.2.0"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f50d9b3dabb09ecd771ad0aa242ca6894994c130308ca3d7684634df8037391"
+checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe"
 
 [[package]]
 name = "opentelemetry"
@@ -5595,11 +5258,11 @@ checksum = "91cf61a1868dacc576bf2b2a1c3e9ab150af7272909e80085c3173384fe11f76"
 dependencies = [
  "async-trait",
  "futures-core",
- "http 1.4.0",
+ "http",
  "opentelemetry",
  "opentelemetry-proto",
  "opentelemetry_sdk",
- "prost",
+ "prost 0.13.5",
  "thiserror 1.0.69",
  "tokio",
  "tonic",
@@ -5614,7 +5277,7 @@ checksum = "a6e05acbfada5ec79023c85368af14abd0b307c015e9064d249b2a950ef459a6"
 dependencies = [
  "opentelemetry",
  "opentelemetry_sdk",
- "prost",
+ "prost 0.13.5",
  "tonic",
 ]
 
@@ -5639,6 +5302,19 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "optd-core"
+version = "0.18.0"
+dependencies = [
+ "anyhow",
+ "bitvec",
+ "itertools 0.14.0",
+ "pretty-xmlish",
+ "snafu 0.8.9",
+ "tokio",
+ "tracing",
+]
+
 [[package]]
 name = "option-ext"
 version = "0.2.0"
@@ -5665,9 +5341,9 @@ dependencies = [
 
 [[package]]
 name = "ordered-float"
-version = "5.1.0"
+version = "5.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f4779c6901a562440c3786d08192c6fbda7c1c2060edd10006b05ee35d10f2d"
+checksum = "b7d950ca161dc355eaf28f82b11345ed76c6e1f6eb1f4f4479e0323b9e2fbd0e"
 dependencies = [
  "num-traits",
 ]
@@ -5703,15 +5379,9 @@ dependencies = [
  "proc-macro2",
  "proc-macro2-diagnostics",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
-[[package]]
-name = "outref"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a80800c0488c3a21695ea981a54918fbb37abf04f4d0720c453632255e2ff0e"
-
 [[package]]
 name = "ownedbytes"
 version = "0.7.0"
@@ -5771,9 +5441,9 @@ dependencies = [
 
 [[package]]
 name = "parquet"
-version = "56.2.0"
+version = "57.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0dbd48ad52d7dccf8ea1b90a3ddbfaea4f69878dd7683e51c507d4bc52b5b27"
+checksum = "6ee96b29972a257b855ff2341b37e61af5f12d6af1158b6dcdb5b31ea07bb3cb"
 dependencies = [
  "ahash",
  "arrow-array",
@@ -5784,24 +5454,21 @@ dependencies = [
  "arrow-schema",
  "arrow-select",
  "base64 0.22.1",
- "brotli 8.0.2",
+ "brotli",
  "bytes",
  "chrono",
  "flate2",
- "futures",
  "half",
  "hashbrown 0.16.1",
- "lz4_flex",
- "num",
+ "lz4_flex 0.12.1",
  "num-bigint",
- "object_store",
+ "num-integer",
+ "num-traits",
  "paste",
- "ring",
  "seq-macro",
  "simdutf8",
  "snap",
  "thrift",
- "tokio",
  "twox-hash",
  "zstd",
 ]
@@ -5859,15 +5526,6 @@ dependencies = [
  "serde_core",
 ]
 
-[[package]]
-name = "pem-rfc7468"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88b39c9bfcfc231068454382784bb460aae594343fb030d46e9f50a645418412"
-dependencies = [
- "base64ct",
-]
-
 [[package]]
 name = "percent-encoding"
 version = "2.3.2"
@@ -5882,9 +5540,9 @@ checksum = "df202b0b0f5b8e389955afd5f27b007b00fb948162953f1db9c70d2c7e3157d7"
 
 [[package]]
 name = "pest"
-version = "2.8.5"
+version = "2.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c9eb05c21a464ea704b53158d358a31e6425db2f63a1a7312268b05fe2b75f7"
+checksum = "e0848c601009d37dfa3430c4666e147e49cdcf1b92ecd3e63657d8a5f19da662"
 dependencies = [
  "memchr",
  "ucd-trie",
@@ -5892,9 +5550,9 @@ dependencies = [
 
 [[package]]
 name = "pest_derive"
-version = "2.8.5"
+version = "2.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68f9dbced329c441fa79d80472764b1a2c7e57123553b8519b36663a2fb234ed"
+checksum = "11f486f1ea21e6c10ed15d5a7c77165d0ee443402f0780849d1768e7d9d6fe77"
 dependencies = [
  "pest",
  "pest_generator",
@@ -5902,22 +5560,22 @@ dependencies = [
 
 [[package]]
 name = "pest_generator"
-version = "2.8.5"
+version = "2.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3bb96d5051a78f44f43c8f712d8e810adb0ebf923fc9ed2655a7f66f63ba8ee5"
+checksum = "8040c4647b13b210a963c1ed407c1ff4fdfa01c31d6d2a098218702e6664f94f"
 dependencies = [
  "pest",
  "pest_meta",
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
 name = "pest_meta"
-version = "2.8.5"
+version = "2.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "602113b5b5e8621770cfd490cfd90b9f84ab29bd2b0e49ad83eb6d186cef2365"
+checksum = "89815c69d36021a140146f26659a81d6c2afa33d216d736dd4be5381a7362220"
 dependencies = [
  "pest",
  "sha2",
@@ -5930,7 +5588,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3672b37090dbd86368a4145bc067582552b29c27377cad4e0a306c97f9bd7772"
 dependencies = [
  "fixedbitset",
- "indexmap 2.13.0",
+ "indexmap 2.14.0",
 ]
 
 [[package]]
@@ -5941,7 +5599,7 @@ checksum = "8701b58ea97060d5e5b155d383a69952a60943f0e6dfe30b04c287beb0b27455"
 dependencies = [
  "fixedbitset",
  "hashbrown 0.15.5",
- "indexmap 2.13.0",
+ "indexmap 2.14.0",
  "serde",
 ]
 
@@ -5994,7 +5652,7 @@ dependencies = [
  "phf_shared 0.11.3",
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -6017,79 +5675,35 @@ dependencies = [
 
 [[package]]
 name = "pin-project"
-version = "1.1.10"
+version = "1.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "677f1add503faace112b9f1373e43e9e054bfdd22ff1a63c1bc485eaec6a6a8a"
+checksum = "f1749c7ed4bcaf4c3d0a3efc28538844fb29bcdd7d2b67b2be7e20ba861ff517"
 dependencies = [
  "pin-project-internal",
 ]
 
 [[package]]
 name = "pin-project-internal"
-version = "1.1.10"
+version = "1.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e918e4ff8c4549eb882f14b3a4bc8c8bc93de829416eacf579f1207a8fbf861"
+checksum = "d9b20ed30f105399776b9c883e68e536ef602a16ae6f596d2c473591d6ad64c6"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
 name = "pin-project-lite"
-version = "0.2.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
-
-[[package]]
-name = "pin-utils"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
-
-[[package]]
-name = "pkcs1"
-version = "0.7.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8ffb9f10fa047879315e6625af03c164b16962a5368d724ed16323b68ace47f"
-dependencies = [
- "der",
- "pkcs8",
- "spki",
-]
-
-[[package]]
-name = "pkcs5"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e847e2c91a18bfa887dd028ec33f2fe6f25db77db3619024764914affe8b69a6"
-dependencies = [
- "aes",
- "cbc",
- "der",
- "pbkdf2",
- "scrypt",
- "sha2",
- "spki",
-]
-
-[[package]]
-name = "pkcs8"
-version = "0.10.2"
+version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
-dependencies = [
- "der",
- "pkcs5",
- "rand_core 0.6.4",
- "spki",
-]
+checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
 
 [[package]]
 name = "pkg-config"
-version = "0.3.32"
+version = "0.3.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
+checksum = "19f132c84eca552bf34cab8ec81f1c1dcc229b811638f9d283dceabe58c5569e"
 
 [[package]]
 name = "plotters"
@@ -6131,14 +5745,14 @@ dependencies = [
  "futures-util",
  "headers",
  "hex",
- "http 1.4.0",
+ "http",
  "http-body-util",
  "httpdate",
- "hyper 1.8.1",
+ "hyper",
  "hyper-util",
  "mime",
  "mime_guess",
- "nix",
+ "nix 0.30.1",
  "parking_lot",
  "percent-encoding",
  "pin-project-lite",
@@ -6151,7 +5765,7 @@ dependencies = [
  "serde_urlencoded",
  "smallvec",
  "sync_wrapper",
- "thiserror 2.0.17",
+ "thiserror 2.0.18",
  "tokio",
  "tokio-tungstenite",
  "tokio-util",
@@ -6168,7 +5782,7 @@ dependencies = [
  "proc-macro-crate",
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -6181,34 +5795,30 @@ dependencies = [
  "concurrent-queue",
  "hermit-abi",
  "pin-project-lite",
- "rustix 1.1.3",
+ "rustix 1.1.4",
  "windows-sys 0.61.2",
 ]
 
-[[package]]
-name = "pometry-storage"
-version = "0.18.0"
-
 [[package]]
 name = "portable-atomic"
-version = "1.13.0"
+version = "1.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f89776e4d69bb58bc6993e99ffa1d11f228b839984854c7daeb5d37f87cbe950"
+checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"
 
 [[package]]
 name = "portable-atomic-util"
-version = "0.2.4"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8a2f0d8d040d7848a709caf78912debcc3f33ee4b3cac47d73d1e1069e83507"
+checksum = "091397be61a01d4be58e7841595bd4bfedb15f1cd54977d79b8271e94ed799a3"
 dependencies = [
  "portable-atomic",
 ]
 
 [[package]]
 name = "potential_utf"
-version = "0.1.4"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b73949432f5e2a09657003c25bca5e19a0e9c84f8058ca374f49e0ebe605af77"
+checksum = "0103b1cef7ec0cf76490e969665504990193874ea05c85ff9bab8b911d0a0564"
 dependencies = [
  "zerovec",
 ]
@@ -6228,6 +5838,12 @@ dependencies = [
  "zerocopy",
 ]
 
+[[package]]
+name = "pretty-xmlish"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96b8aab53732b7a9c5c39bb0e130f85671b48b188ef258c3b9f7f5da1877382a"
+
 [[package]]
 name = "pretty_assertions"
 version = "1.4.1"
@@ -6245,23 +5861,23 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
 dependencies = [
  "proc-macro2",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
 name = "proc-macro-crate"
-version = "3.4.0"
+version = "3.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "219cb19e96be00ab2e37d6e299658a0cfa83e52429179969b0f0121b4ac46983"
+checksum = "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f"
 dependencies = [
- "toml_edit 0.23.10+spec-1.0.0",
+ "toml_edit 0.25.11+spec-1.1.0",
 ]
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.105"
+version = "1.0.106"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "535d180e0ecab6268a3e718bb9fd44db66bbbc256257165fc699dadf70d16fe7"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
 dependencies = [
  "unicode-ident",
 ]
@@ -6274,22 +5890,22 @@ checksum = "af066a9c399a26e020ada66a034357a868728e72cd426f3adcd35f80d88d88c8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
  "version_check",
  "yansi",
 ]
 
 [[package]]
 name = "proptest"
-version = "1.9.0"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bee689443a2bd0a16ab0348b52ee43e3b2d1b1f931c8aa5c9f8de4c86fbe8c40"
+checksum = "4b45fcc2344c680f5025fe57779faef368840d0bd1f42f216291f0dc4ace4744"
 dependencies = [
  "bit-set",
  "bit-vec",
  "bitflags",
  "num-traits",
- "rand 0.9.2",
+ "rand 0.9.4",
  "rand_chacha 0.9.0",
  "rand_xorshift",
  "regex-syntax",
@@ -6300,13 +5916,13 @@ dependencies = [
 
 [[package]]
 name = "proptest-derive"
-version = "0.5.1"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ee1c9ac207483d5e7db4940700de86a9aae46ef90c48b57f99fe7edb8345e49"
+checksum = "095a99f75c69734802359b682be8daaf8980296731f6470434ea2c652af1dd30"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -6316,7 +5932,17 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2796faa41db3ec313a31f7624d9286acf277b52de526150b7e69f3debf891ee5"
 dependencies = [
  "bytes",
- "prost-derive",
+ "prost-derive 0.13.5",
+]
+
+[[package]]
+name = "prost"
+version = "0.14.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2ea70524a2f82d518bce41317d0fae74151505651af45faf1ffbd6fd33f0568"
+dependencies = [
+ "bytes",
+ "prost-derive 0.14.3",
 ]
 
 [[package]]
@@ -6332,10 +5958,29 @@ dependencies = [
  "once_cell",
  "petgraph 0.7.1",
  "prettyplease",
- "prost",
- "prost-types",
+ "prost 0.13.5",
+ "prost-types 0.13.5",
+ "regex",
+ "syn 2.0.117",
+ "tempfile",
+]
+
+[[package]]
+name = "prost-build"
+version = "0.14.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "343d3bd7056eda839b03204e68deff7d1b13aba7af2b2fd16890697274262ee7"
+dependencies = [
+ "heck 0.5.0",
+ "itertools 0.14.0",
+ "log",
+ "multimap",
+ "petgraph 0.8.3",
+ "prettyplease",
+ "prost 0.14.3",
+ "prost-types 0.14.3",
  "regex",
- "syn 2.0.114",
+ "syn 2.0.117",
  "tempfile",
 ]
 
@@ -6349,7 +5994,20 @@ dependencies = [
  "itertools 0.14.0",
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "prost-derive"
+version = "0.14.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27c6023962132f4b30eb4c172c91ce92d933da334c59c23cddee82358ddafb0b"
+dependencies = [
+ "anyhow",
+ "itertools 0.14.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -6358,28 +6016,27 @@ version = "0.13.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "52c2c1bf36ddb1a1c396b3601a3cec27c2462e45f07c386894ec3ccf5332bd16"
 dependencies = [
- "prost",
+ "prost 0.13.5",
 ]
 
 [[package]]
-name = "psm"
-version = "0.1.28"
+name = "prost-types"
+version = "0.14.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d11f2fedc3b7dafdc2851bc52f277377c5473d378859be234bc7ebb593144d01"
+checksum = "8991c4cbdb8bc5b11f0b074ffe286c30e523de90fee5ba8132f1399f23cb3dd7"
 dependencies = [
- "ar_archive_writer",
- "cc",
+ "prost 0.14.3",
 ]
 
 [[package]]
 name = "pyo3"
-version = "0.25.1"
+version = "0.27.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8970a78afe0628a3e3430376fc5fd76b6b45c4d43360ffd6cdd40bdde72b682a"
+checksum = "ab53c047fcd1a1d2a8820fe84f05d6be69e9526be40cb03b73f86b6b03e6d87d"
 dependencies = [
  "chrono",
  "chrono-tz 0.10.4",
- "indexmap 2.13.0",
+ "indexmap 2.14.0",
  "indoc",
  "inventory",
  "libc",
@@ -6394,9 +6051,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-arrow"
-version = "0.11.0"
+version = "0.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8454903e6b8406a98c9210e828f85af167aef1816208a1c04e837185a49eee5b"
+checksum = "36b9f03cb749b0326951ebb30e39eda2f32b0b9205dce67e947e65779b8faffc"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -6404,8 +6061,10 @@ dependencies = [
  "arrow-data",
  "arrow-schema",
  "arrow-select",
+ "chrono",
+ "chrono-tz 0.10.4",
  "half",
- "indexmap 2.13.0",
+ "indexmap 2.14.0",
  "numpy",
  "pyo3",
  "thiserror 1.0.69",
@@ -6413,19 +6072,18 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.25.1"
+version = "0.27.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "458eb0c55e7ece017adeba38f2248ff3ac615e53660d7c71a238d7d2a01c7598"
+checksum = "b455933107de8642b4487ed26d912c2d899dec6114884214a0b3bb3be9261ea6"
 dependencies = [
- "once_cell",
  "target-lexicon",
 ]
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.25.1"
+version = "0.27.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7114fe5457c61b276ab77c5055f206295b812608083644a5c5b2640c3102565c"
+checksum = "1c85c9cbfaddf651b1221594209aed57e9e5cff63c4d11d1feead529b872a089"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -6433,27 +6091,37 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.25.1"
+version = "0.27.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8725c0a622b374d6cb051d11a0983786448f7785336139c3c94f5aa6bef7e50"
+checksum = "0a5b10c9bf9888125d917fb4d2ca2d25c8df94c7ab5a52e13313a07e050a3b02"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.25.1"
+version = "0.27.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4109984c22491085343c05b0dbc54ddc405c3cf7b4374fc533f5c3313a572ccc"
+checksum = "03b51720d314836e53327f5871d4c0cfb4fb37cc2c4a11cc71907a86342c40f9"
 dependencies = [
  "heck 0.5.0",
  "proc-macro2",
  "pyo3-build-config",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "pythonize"
+version = "0.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3a8f29db331e28c332c63496cfcbb822aca3d7320bc08b655d7fd0c29c50ede"
+dependencies = [
+ "pyo3",
+ "serde",
 ]
 
 [[package]]
@@ -6468,46 +6136,15 @@ version = "1.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
 
-[[package]]
-name = "quick-xml"
-version = "0.37.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "331e97a1af0bf59823e6eadffe373d7b27f485be8748f71471c662c1f269b7fb"
-dependencies = [
- "memchr",
- "serde",
-]
-
-[[package]]
-name = "quick-xml"
-version = "0.38.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b66c2058c55a409d601666cffe35f04333cf1013010882cec174a7467cd4e21c"
-dependencies = [
- "memchr",
- "serde",
-]
-
 [[package]]
 name = "quickcheck"
-version = "1.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "588f6378e4dd99458b60ec275b4477add41ce4fa9f64dcba6f15adccb19b50d6"
-dependencies = [
- "env_logger",
- "log",
- "rand 0.8.5",
-]
-
-[[package]]
-name = "quickcheck_macros"
 version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f71ee38b42f8459a88d3362be6f9b841ad2d5421844f61eb1c59c11bff3ac14a"
+checksum = "95c589f335db0f6aaa168a7cd27b1fc6920f5e1470c804f814d9cd6e62a0f70b"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.114",
+ "env_logger 0.11.10",
+ "log",
+ "rand 0.10.1",
 ]
 
 [[package]]
@@ -6521,10 +6158,10 @@ dependencies = [
  "pin-project-lite",
  "quinn-proto",
  "quinn-udp",
- "rustc-hash 2.1.1",
- "rustls 0.23.36",
- "socket2 0.6.1",
- "thiserror 2.0.17",
+ "rustc-hash 2.1.2",
+ "rustls",
+ "socket2 0.6.3",
+ "thiserror 2.0.18",
  "tokio",
  "tracing",
  "web-time",
@@ -6532,20 +6169,20 @@ dependencies = [
 
 [[package]]
 name = "quinn-proto"
-version = "0.11.13"
+version = "0.11.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1906b49b0c3bc04b5fe5d86a77925ae6524a19b816ae38ce1e426255f1d8a31"
+checksum = "434b42fec591c96ef50e21e886936e66d3cc3f737104fdb9b737c40ffb94c098"
 dependencies = [
  "bytes",
  "getrandom 0.3.4",
  "lru-slab",
- "rand 0.9.2",
+ "rand 0.9.4",
  "ring",
- "rustc-hash 2.1.1",
- "rustls 0.23.36",
+ "rustc-hash 2.1.2",
+ "rustls",
  "rustls-pki-types",
  "slab",
- "thiserror 2.0.17",
+ "thiserror 2.0.18",
  "tinyvec",
  "tracing",
  "web-time",
@@ -6560,16 +6197,16 @@ dependencies = [
  "cfg_aliases",
  "libc",
  "once_cell",
- "socket2 0.6.1",
+ "socket2 0.6.3",
  "tracing",
  "windows-sys 0.60.2",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.43"
+version = "1.0.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc74d9a594b72ae6656596548f56f667211f8a97b3d4c3d467150794690dc40a"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
 dependencies = [
  "proc-macro2",
 ]
@@ -6580,12 +6217,28 @@ version = "5.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
 
+[[package]]
+name = "r-efi"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
+
 [[package]]
 name = "radium"
 version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
 
+[[package]]
+name = "radix_trie"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c069c179fcdc6a2fe24d8d18305cf085fdbd4f922c041943e203685d6a1c58fd"
+dependencies = [
+ "endian-type",
+ "nibble_vec",
+]
+
 [[package]]
 name = "rand"
 version = "0.8.5"
@@ -6599,14 +6252,24 @@ dependencies = [
 
 [[package]]
 name = "rand"
-version = "0.9.2"
+version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
+checksum = "44c5af06bb1b7d3216d91932aed5265164bf384dc89cd6ba05cf59a35f5f76ea"
 dependencies = [
  "rand_chacha 0.9.0",
  "rand_core 0.9.5",
 ]
 
+[[package]]
+name = "rand"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2e8e8bcc7961af1fdac401278c6a831614941f6164ee3bf4ce61b7edb162207"
+dependencies = [
+ "getrandom 0.4.2",
+ "rand_core 0.10.1",
+]
+
 [[package]]
 name = "rand_chacha"
 version = "0.3.1"
@@ -6645,6 +6308,12 @@ dependencies = [
  "getrandom 0.3.4",
 ]
 
+[[package]]
+name = "rand_core"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69"
+
 [[package]]
 name = "rand_distr"
 version = "0.4.3"
@@ -6662,7 +6331,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6a8615d50dcf34fa31f7ab52692afec947c4dd0ab803cc87cb3b0b4570ff7463"
 dependencies = [
  "num-traits",
- "rand 0.9.2",
+ "rand 0.9.4",
 ]
 
 [[package]]
@@ -6690,9 +6359,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e47a395bdb55442b883c89062d6bcff25dc90fa5f8369af81e0ac6d49d78cf81"
 dependencies = [
  "ahash",
- "brotli 8.0.2",
+ "brotli",
  "paste",
- "rand 0.9.2",
+ "rand 0.9.4",
  "unicase",
 ]
 
@@ -6709,18 +6378,15 @@ dependencies = [
  "ahash",
  "arrow",
  "arrow-array",
- "arrow-buffer",
  "arrow-csv",
- "arrow-data",
- "arrow-ipc",
  "arrow-json",
  "arrow-schema",
  "arrow-select",
  "async-openai",
  "async-trait",
- "axum 0.8.8",
+ "axum 0.8.9",
  "bigdecimal",
- "bincode",
+ "bincode 2.0.1",
  "bytemuck",
  "bzip2 0.4.4",
  "chrono",
@@ -6730,15 +6396,18 @@ dependencies = [
  "datafusion-physical-expr",
  "datafusion-physical-expr-common",
  "datafusion-physical-plan",
+ "db4-graph",
+ "db4-storage",
+ "disjoint-sets",
  "display-error-chain",
  "dotenv",
  "either",
  "flate2",
  "futures-util",
  "glam",
- "hashbrown 0.15.5",
+ "hashbrown 0.14.5",
  "heed",
- "indexmap 2.13.0",
+ "indexmap 2.14.0",
  "indoc",
  "iter-enum",
  "itertools 0.13.0",
@@ -6758,20 +6427,18 @@ dependencies = [
  "ouroboros",
  "parking_lot",
  "parquet",
- "pometry-storage",
  "pretty_assertions",
  "proptest",
  "proptest-derive",
- "prost",
- "prost-build",
- "prost-types",
+ "prost 0.13.5",
+ "prost-build 0.13.5",
+ "prost-types 0.13.5",
  "pyo3",
  "pyo3-arrow",
+ "pythonize",
  "quad-rand",
- "quickcheck",
- "quickcheck_macros",
- "rand 0.8.5",
- "rand_distr 0.4.3",
+ "rand 0.9.4",
+ "rand_distr 0.5.1",
  "raphtory",
  "raphtory-api",
  "raphtory-core",
@@ -6779,8 +6446,8 @@ dependencies = [
  "rayon",
  "regex",
  "reqwest",
- "roaring",
- "rustc-hash 2.1.1",
+ "roaring 0.10.12",
+ "rustc-hash 2.1.2",
  "serde",
  "serde_arrow",
  "serde_json",
@@ -6788,7 +6455,8 @@ dependencies = [
  "strsim",
  "tantivy 0.22.1",
  "tempfile",
- "thiserror 2.0.17",
+ "thiserror 2.0.18",
+ "tikv-jemallocator",
  "tokio",
  "tracing",
  "uuid",
@@ -6801,12 +6469,14 @@ name = "raphtory-api"
 version = "0.18.0"
 dependencies = [
  "arrow-array",
+ "arrow-buffer",
  "arrow-ipc",
  "arrow-schema",
  "bigdecimal",
  "bytemuck",
  "chrono",
  "dashmap",
+ "derive_more",
  "display-error-chain",
  "iter-enum",
  "itertools 0.13.0",
@@ -6817,18 +6487,32 @@ dependencies = [
  "proptest",
  "pyo3",
  "pyo3-arrow",
- "rand 0.8.5",
+ "rand 0.9.4",
  "rayon",
- "rustc-hash 2.1.1",
+ "rustc-hash 2.1.2",
  "serde",
+ "serde_arrow",
  "serde_json",
  "sorted_vector_map",
- "thiserror 2.0.17",
+ "thiserror 2.0.18",
  "tracing",
  "tracing-subscriber",
  "twox-hash",
 ]
 
+[[package]]
+name = "raphtory-api-macros"
+version = "0.18.0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "raphtory-auth-noop"
+version = "0.18.0"
+
 [[package]]
 name = "raphtory-benchmark"
 version = "0.18.0"
@@ -6839,7 +6523,7 @@ dependencies = [
  "fake",
  "itertools 0.13.0",
  "once_cell",
- "rand 0.8.5",
+ "rand 0.9.4",
  "raphtory",
  "raphtory-api",
  "rayon",
@@ -6854,10 +6538,15 @@ dependencies = [
 name = "raphtory-core"
 version = "0.18.0"
 dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
  "bigdecimal",
  "chrono",
  "dashmap",
  "either",
+ "hashbrown 0.14.5",
  "iter-enum",
  "itertools 0.13.0",
  "lock_api",
@@ -6869,39 +6558,9 @@ dependencies = [
  "raphtory-api",
  "rayon",
  "regex",
- "rustc-hash 2.1.1",
- "serde",
- "thiserror 2.0.17",
-]
-
-[[package]]
-name = "raphtory-cypher"
-version = "0.18.0"
-dependencies = [
- "arrow",
- "arrow-array",
- "arrow-buffer",
- "arrow-schema",
- "async-trait",
- "clap",
- "datafusion",
- "futures",
- "itertools 0.13.0",
- "lazy_static",
- "pest",
- "pest_derive",
- "pometry-storage",
- "pretty_assertions",
- "proptest",
- "raphtory",
- "rayon",
+ "rustc-hash 2.1.2",
  "serde",
- "serde_json",
- "sqlparser",
- "tempfile",
- "thiserror 2.0.17",
- "tokio",
- "tracing",
+ "thiserror 2.0.18",
 ]
 
 [[package]]
@@ -6914,6 +6573,7 @@ dependencies = [
  "async-graphql-poem",
  "base64 0.22.1",
  "base64-compat",
+ "bigdecimal",
  "chrono",
  "clap",
  "config",
@@ -6921,7 +6581,7 @@ dependencies = [
  "dynamic-graphql",
  "futures-util",
  "itertools 0.13.0",
- "jsonwebtoken 10.3.0",
+ "jsonwebtoken",
  "minijinja",
  "moka",
  "once_cell",
@@ -6939,14 +6599,14 @@ dependencies = [
  "rayon",
  "reqwest",
  "rust-embed",
- "rustc-hash 2.1.1",
+ "rustc-hash 2.1.2",
  "serde",
  "serde_json",
  "spki",
  "strum 0.27.2",
  "strum_macros 0.27.2",
  "tempfile",
- "thiserror 2.0.17",
+ "thiserror 2.0.18",
  "tokio",
  "tracing",
  "tracing-opentelemetry",
@@ -6956,14 +6616,35 @@ dependencies = [
  "zip",
 ]
 
+[[package]]
+name = "raphtory-itertools"
+version = "0.18.0"
+dependencies = [
+ "criterion",
+ "itertools 0.13.0",
+ "proptest",
+ "rand 0.9.4",
+]
+
 [[package]]
 name = "raphtory-pymodule"
 version = "0.18.0"
 dependencies = [
+ "clam-core",
  "pyo3",
  "pyo3-build-config",
  "raphtory",
+ "raphtory-auth-noop",
+ "raphtory-graphql",
+]
+
+[[package]]
+name = "raphtory-server"
+version = "0.18.0"
+dependencies = [
+ "raphtory-auth-noop",
  "raphtory-graphql",
+ "tokio",
 ]
 
 [[package]]
@@ -6973,18 +6654,20 @@ dependencies = [
  "arrow-array",
  "arrow-schema",
  "bigdecimal",
+ "db4-graph",
+ "db4-storage",
  "iter-enum",
  "itertools 0.13.0",
  "num-traits",
  "parking_lot",
- "pometry-storage",
  "proptest",
  "raphtory-api",
+ "raphtory-api-macros",
  "raphtory-core",
  "rayon",
  "serde",
  "tempfile",
- "thiserror 2.0.17",
+ "thiserror 2.0.18",
 ]
 
 [[package]]
@@ -7017,9 +6700,9 @@ checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3"
 
 [[package]]
 name = "rayon"
-version = "1.11.0"
+version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "368f01d005bf8fd9b1206fb6fa653e6c4a81ceb1466406b81792d87c5677a58f"
+checksum = "fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d"
 dependencies = [
  "either",
  "rayon-core",
@@ -7035,26 +6718,6 @@ dependencies = [
  "crossbeam-utils",
 ]
 
-[[package]]
-name = "recursive"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0786a43debb760f491b1bc0269fe5e84155353c67482b9e60d0cfb596054b43e"
-dependencies = [
- "recursive-proc-macro-impl",
- "stacker",
-]
-
-[[package]]
-name = "recursive-proc-macro-impl"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76009fbe0614077fc1a2ce255e3a1881a2e3a3527097d5dc6d8212c585e7e38b"
-dependencies = [
- "quote",
- "syn 2.0.114",
-]
-
 [[package]]
 name = "redox_syscall"
 version = "0.5.18"
@@ -7072,7 +6735,7 @@ checksum = "a4e608c6638b9c18977b00b475ac1f28d14e84b27d8d42f70e0bf1e3dec127ac"
 dependencies = [
  "getrandom 0.2.17",
  "libredox",
- "thiserror 2.0.17",
+ "thiserror 2.0.18",
 ]
 
 [[package]]
@@ -7092,14 +6755,14 @@ checksum = "b7186006dcb21920990093f30e3dea63b7d6e977bf1256be20c3563a5db070da"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
 name = "regex"
-version = "1.12.2"
+version = "1.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "843bc0191f75f3e22651ae5f1e72939ab2f72a4bc30fa80a066bd66edefc24d4"
+checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -7109,58 +6772,20 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.4.13"
+version = "0.4.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5276caf25ac86c8d810222b3dbb938e512c55c6831a10f3e6ed1c93b84041f1c"
+checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f"
 dependencies = [
  "aho-corasick",
  "memchr",
  "regex-syntax",
 ]
 
-[[package]]
-name = "regex-lite"
-version = "0.1.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d942b98df5e658f56f20d592c7f868833fe38115e65c33003d8cd224b0155da"
-
 [[package]]
 name = "regex-syntax"
-version = "0.8.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58"
-
-[[package]]
-name = "reqsign"
-version = "0.16.5"
+version = "0.8.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43451dbf3590a7590684c25fb8d12ecdcc90ed3ac123433e500447c7d77ed701"
-dependencies = [
- "anyhow",
- "async-trait",
- "base64 0.22.1",
- "chrono",
- "form_urlencoded",
- "getrandom 0.2.17",
- "hex",
- "hmac",
- "home",
- "http 1.4.0",
- "jsonwebtoken 9.3.1",
- "log",
- "once_cell",
- "percent-encoding",
- "quick-xml 0.37.5",
- "rand 0.8.5",
- "reqwest",
- "rsa",
- "rust-ini 0.21.3",
- "serde",
- "serde_json",
- "sha1",
- "sha2",
- "tokio",
-]
+checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"
 
 [[package]]
 name = "reqwest"
@@ -7174,12 +6799,12 @@ dependencies = [
  "futures-channel",
  "futures-core",
  "futures-util",
- "h2 0.4.13",
- "http 1.4.0",
- "http-body 1.0.1",
+ "h2",
+ "http",
+ "http-body",
  "http-body-util",
- "hyper 1.8.1",
- "hyper-rustls 0.27.7",
+ "hyper",
+ "hyper-rustls",
  "hyper-util",
  "js-sys",
  "log",
@@ -7188,7 +6813,7 @@ dependencies = [
  "percent-encoding",
  "pin-project-lite",
  "quinn",
- "rustls 0.23.36",
+ "rustls",
  "rustls-native-certs 0.8.3",
  "rustls-pki-types",
  "serde",
@@ -7196,7 +6821,7 @@ dependencies = [
  "serde_urlencoded",
  "sync_wrapper",
  "tokio",
- "tokio-rustls 0.26.4",
+ "tokio-rustls",
  "tokio-util",
  "tower 0.5.3",
  "tower-http",
@@ -7206,7 +6831,7 @@ dependencies = [
  "wasm-bindgen-futures",
  "wasm-streams",
  "web-sys",
- "webpki-roots 1.0.5",
+ "webpki-roots 1.0.6",
 ]
 
 [[package]]
@@ -7264,6 +6889,16 @@ dependencies = [
  "byteorder",
 ]
 
+[[package]]
+name = "roaring"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ba9ce64a8f45d7fc86358410bb1a82e8c987504c0d4900e9141d69a9f26c885"
+dependencies = [
+ "bytemuck",
+ "byteorder",
+]
+
 [[package]]
 name = "ron"
 version = "0.8.1"
@@ -7276,32 +6911,11 @@ dependencies = [
  "serde_derive",
 ]
 
-[[package]]
-name = "rsa"
-version = "0.9.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8573f03f5883dcaebdfcf4725caa1ecb9c15b2ef50c43a07b816e06799bb12d"
-dependencies = [
- "const-oid",
- "digest",
- "num-bigint-dig",
- "num-integer",
- "num-traits",
- "pkcs1",
- "pkcs8",
- "rand_core 0.6.4",
- "sha2",
- "signature",
- "spki",
- "subtle",
- "zeroize",
-]
-
 [[package]]
 name = "rust-embed"
-version = "8.10.0"
+version = "8.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f783a9e226b5319beefe29d45941f559ace8b56801bb8355be17eea277fc8272"
+checksum = "04113cb9355a377d83f06ef1f0a45b8ab8cd7d8b1288160717d66df5c7988d27"
 dependencies = [
  "rust-embed-impl",
  "rust-embed-utils",
@@ -7310,23 +6924,23 @@ dependencies = [
 
 [[package]]
 name = "rust-embed-impl"
-version = "8.10.0"
+version = "8.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "303d4e979140595f1d824b3dd53a32684835fa32425542056826521ac279f538"
+checksum = "da0902e4c7c8e997159ab384e6d0fc91c221375f6894346ae107f47dd0f3ccaa"
 dependencies = [
  "proc-macro2",
  "quote",
  "rust-embed-utils",
  "shellexpand",
- "syn 2.0.114",
+ "syn 2.0.117",
  "walkdir",
 ]
 
 [[package]]
 name = "rust-embed-utils"
-version = "8.10.0"
+version = "8.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f6b4ab509cae251bd524d2425d746b0af0018f5a81fc1eaecdd4e661c8ab3a0"
+checksum = "5bcdef0be6fe7f6fa333b1073c949729274b05f123a0ad7efcb8efd878e5c3b1"
 dependencies = [
  "sha2",
  "walkdir",
@@ -7354,16 +6968,6 @@ dependencies = [
  "ordered-multimap",
 ]
 
-[[package]]
-name = "rust-ini"
-version = "0.21.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "796e8d2b6696392a43bea58116b667fb4c29727dc5abd27d6acf338bb4f688c7"
-dependencies = [
- "cfg-if",
- "ordered-multimap",
-]
-
 [[package]]
 name = "rust-stemmers"
 version = "1.2.0"
@@ -7382,9 +6986,9 @@ checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
 [[package]]
 name = "rustc-hash"
-version = "2.1.1"
+version = "2.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
+checksum = "94300abf3f1ae2e2b8ffb7b58043de3d399c73fa6f4b73826402a5c457614dbe"
 
 [[package]]
 name = "rustc_version"
@@ -7410,40 +7014,27 @@ dependencies = [
 
 [[package]]
 name = "rustix"
-version = "1.1.3"
+version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "146c9e247ccc180c1f61615433868c99f3de3ae256a30a43b49f67c2d9171f34"
+checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
 dependencies = [
  "bitflags",
  "errno",
  "libc",
- "linux-raw-sys 0.11.0",
+ "linux-raw-sys 0.12.1",
  "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "rustls"
-version = "0.21.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f56a14d1f48b391359b22f731fd4bd7e43c97f3c50eee276f3aa09c94784d3e"
-dependencies = [
- "log",
- "ring",
- "rustls-webpki 0.101.7",
- "sct",
-]
-
-[[package]]
-name = "rustls"
-version = "0.23.36"
+version = "0.23.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c665f33d38cea657d9614f766881e4d510e0eda4239891eea56b4cadcf01801b"
+checksum = "69f9466fb2c14ea04357e91413efb882e2a6d4a406e625449bc0a5d360d53a21"
 dependencies = [
- "aws-lc-rs",
  "once_cell",
  "ring",
  "rustls-pki-types",
- "rustls-webpki 0.103.8",
+ "rustls-webpki",
  "subtle",
  "zeroize",
 ]
@@ -7467,10 +7058,10 @@ version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "612460d5f7bea540c490b2b6395d8e34a953e52b491accd6c86c8164c5932a63"
 dependencies = [
- "openssl-probe 0.2.0",
+ "openssl-probe 0.2.1",
  "rustls-pki-types",
  "schannel",
- "security-framework 3.5.1",
+ "security-framework 3.7.0",
 ]
 
 [[package]]
@@ -7484,9 +7075,9 @@ dependencies = [
 
 [[package]]
 name = "rustls-pki-types"
-version = "1.13.2"
+version = "1.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21e6f2ab2928ca4291b86736a8bd920a277a399bba1589409d72154ff87c1282"
+checksum = "be040f8b0a225e40375822a563fa9524378b9d63112f53e19ffff34df5d33fdd"
 dependencies = [
  "web-time",
  "zeroize",
@@ -7494,21 +7085,10 @@ dependencies = [
 
 [[package]]
 name = "rustls-webpki"
-version = "0.101.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765"
-dependencies = [
- "ring",
- "untrusted 0.9.0",
-]
-
-[[package]]
-name = "rustls-webpki"
-version = "0.103.8"
+version = "0.103.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ffdfa2f5286e2247234e03f680868ac2815974dc39e00ea15adc445d0aafe52"
+checksum = "8279bb85272c9f10811ae6a6c547ff594d6a7f3c6c6b02ee9726d1d0dcfcdd06"
 dependencies = [
- "aws-lc-rs",
  "ring",
  "rustls-pki-types",
  "untrusted 0.9.0",
@@ -7533,19 +7113,32 @@ dependencies = [
 ]
 
 [[package]]
-name = "ryu"
-version = "1.0.22"
+name = "rustyline"
+version = "13.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a50f4cf475b65d88e057964e0e9bb1f0aa9bbb2036dc65c64596b42932536984"
+checksum = "02a2d683a4ac90aeef5b1013933f6d977bd37d51ff3f4dad829d4931a7e6be86"
+dependencies = [
+ "bitflags",
+ "cfg-if",
+ "clipboard-win",
+ "fd-lock",
+ "home",
+ "libc",
+ "log",
+ "memchr",
+ "nix 0.27.1",
+ "radix_trie",
+ "unicode-segmentation",
+ "unicode-width 0.1.14",
+ "utf8parse",
+ "winapi",
+]
 
 [[package]]
-name = "salsa20"
-version = "0.10.2"
+name = "ryu"
+version = "1.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97a22f5af31f73a954c10289c93e8a50cc23d971e80ee446f1f6f7137a088213"
-dependencies = [
- "cipher",
-]
+checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f"
 
 [[package]]
 name = "same-file"
@@ -7558,9 +7151,9 @@ dependencies = [
 
 [[package]]
 name = "schannel"
-version = "0.1.28"
+version = "0.1.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "891d81b926048e76efe18581bf793546b4c0eaf8448d72be8de2bbee5fd166e1"
+checksum = "91c1b7e4904c873ef0710c1f407dde2e6287de2bebc1bbbf7d430bb7cbffd939"
 dependencies = [
  "windows-sys 0.61.2",
 ]
@@ -7579,9 +7172,9 @@ dependencies = [
 
 [[package]]
 name = "schemars"
-version = "1.2.0"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "54e910108742c57a770f492731f99be216a52fadd361b06c8fb59d74ccc267d2"
+checksum = "a2b42f36aa1cd011945615b92222f6bf73c599a102a300334cd7f8dbeec726cc"
 dependencies = [
  "dyn-clone",
  "ref-cast",
@@ -7593,34 +7186,13 @@ dependencies = [
 name = "scoped-tls"
 version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"
-
-[[package]]
-name = "scopeguard"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
-
-[[package]]
-name = "scrypt"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0516a385866c09368f0b5bcd1caff3366aace790fcd46e2bb032697bb172fd1f"
-dependencies = [
- "pbkdf2",
- "salsa20",
- "sha2",
-]
+checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"
 
 [[package]]
-name = "sct"
-version = "0.7.1"
+name = "scopeguard"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414"
-dependencies = [
- "ring",
- "untrusted 0.9.0",
-]
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
 [[package]]
 name = "secrecy"
@@ -7647,9 +7219,9 @@ dependencies = [
 
 [[package]]
 name = "security-framework"
-version = "3.5.1"
+version = "3.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b3297343eaf830f66ede390ea39da1d462b6b0c1b000f420d0a83f898bbbe6ef"
+checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d"
 dependencies = [
  "bitflags",
  "core-foundation 0.10.1",
@@ -7660,9 +7232,9 @@ dependencies = [
 
 [[package]]
 name = "security-framework-sys"
-version = "2.15.0"
+version = "2.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc1f0cbffaac4852523ce30d8bd3c5cdc873501d96ff467ca09b6767bb8cd5c0"
+checksum = "6ce2691df843ecc5d231c0b14ece2acc3efb62c0a398c7e1d875f3983ce020e3"
 dependencies = [
  "core-foundation-sys",
  "libc",
@@ -7670,9 +7242,9 @@ dependencies = [
 
 [[package]]
 name = "semver"
-version = "1.0.27"
+version = "1.0.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2"
+checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
 
 [[package]]
 name = "seq-macro"
@@ -7722,7 +7294,7 @@ checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -7757,7 +7329,7 @@ checksum = "175ee3e80ae9982737ca543e96133087cbd9a485eecc3bc4de9c1a37b47ea59c"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -7783,17 +7355,17 @@ dependencies = [
 
 [[package]]
 name = "serde_with"
-version = "3.16.1"
+version = "3.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fa237f2807440d238e0364a218270b98f767a00d3dada77b1c53ae88940e2e7"
+checksum = "dd5414fad8e6907dbdd5bc441a50ae8d6e26151a03b1de04d89a5576de61d01f"
 dependencies = [
  "base64 0.22.1",
  "chrono",
  "hex",
  "indexmap 1.9.3",
- "indexmap 2.13.0",
+ "indexmap 2.14.0",
  "schemars 0.9.0",
- "schemars 1.2.0",
+ "schemars 1.2.1",
  "serde_core",
  "serde_json",
  "serde_with_macros",
@@ -7802,14 +7374,14 @@ dependencies = [
 
 [[package]]
 name = "serde_with_macros"
-version = "3.16.1"
+version = "3.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52a8e3ca0ca629121f70ab50f95249e5a6f925cc0f6ffe8256c45b728875706c"
+checksum = "d3db8978e608f1fe7357e211969fd9abdcae80bac1ba7a3369bb7eb6b404eb65"
 dependencies = [
- "darling 0.21.3",
+ "darling 0.23.0",
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -7819,7 +7391,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
 dependencies = [
  "cfg-if",
- "cpufeatures",
+ "cpufeatures 0.2.17",
  "digest",
 ]
 
@@ -7830,7 +7402,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
 dependencies = [
  "cfg-if",
- "cpufeatures",
+ "cpufeatures 0.2.17",
  "digest",
 ]
 
@@ -7845,9 +7417,9 @@ dependencies = [
 
 [[package]]
 name = "shellexpand"
-version = "3.1.1"
+version = "3.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b1fdf65dd6331831494dd616b30351c38e96e45921a27745cf98490458b90bb"
+checksum = "32824fab5e16e6c4d86dc1ba84489390419a39f97699852b66480bb87d297ed8"
 dependencies = [
  "dirs",
 ]
@@ -7874,15 +7446,14 @@ version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
 dependencies = [
- "digest",
  "rand_core 0.6.4",
 ]
 
 [[package]]
 name = "simd-adler32"
-version = "0.3.8"
+version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e320a6c5ad31d271ad523dcf3ad13e2767ad8b1cb8f047f75a8aeaf8da139da2"
+checksum = "703d5c7ef118737c72f1af64ad2f6f8c5e1921f818cdcb97b8fe6fc69bf66214"
 
 [[package]]
 name = "simdutf8"
@@ -7890,6 +7461,12 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e"
 
+[[package]]
+name = "similar"
+version = "2.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbbb5d9659141646ae647b42fe094daf6c6192d1620870b449d9557f748b2daa"
+
 [[package]]
 name = "simple_asn1"
 version = "0.6.4"
@@ -7898,15 +7475,15 @@ checksum = "0d585997b0ac10be3c5ee635f1bab02d512760d14b7c468801ac8a01d9ae5f1d"
 dependencies = [
  "num-bigint",
  "num-traits",
- "thiserror 2.0.17",
+ "thiserror 2.0.18",
  "time",
 ]
 
 [[package]]
 name = "siphasher"
-version = "1.0.1"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"
+checksum = "b2aa850e253778c88a04c3d7323b043aeda9d3e30d5971937c1855769763678e"
 
 [[package]]
 name = "sketches-ddsketch"
@@ -7919,18 +7496,27 @@ dependencies = [
 
 [[package]]
 name = "sketches-ddsketch"
-version = "0.3.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1e9a774a6c28142ac54bb25d25562e6bcf957493a184f15ad4eebccb23e410a"
+checksum = "0c6f73aeb92d671e0cc4dca167e59b2deb6387c375391bc99ee743f326994a2b"
 dependencies = [
  "serde",
 ]
 
 [[package]]
 name = "slab"
-version = "0.4.11"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
+
+[[package]]
+name = "slotmap"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589"
+checksum = "bdd58c3c93c3d278ca835519292445cb4b0d4dc59ccfdf7ceadaab3f8aeb4038"
+dependencies = [
+ "version_check",
+]
 
 [[package]]
 name = "smallvec"
@@ -7944,7 +7530,16 @@ version = "0.8.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6e84b3f4eacbf3a1ce05eac6763b4d629d60cbc94d632e4092c54ade71f1e1a2"
 dependencies = [
- "snafu-derive",
+ "snafu-derive 0.8.9",
+]
+
+[[package]]
+name = "snafu"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d1d4bced6a69f90b2056c03dcff2c4737f98d6fb9e0853493996e1d253ca29c6"
+dependencies = [
+ "snafu-derive 0.9.0",
 ]
 
 [[package]]
@@ -7956,7 +7551,19 @@ dependencies = [
  "heck 0.5.0",
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "snafu-derive"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "54254b8531cafa275c5e096f62d48c81435d1015405a91198ddb11e967301d40"
+dependencies = [
+ "heck 0.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -7965,6 +7572,15 @@ version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1b6b67fb9a61334225b5b790716f609cd58395f895b3fe8b328786812a40bc3b"
 
+[[package]]
+name = "snb"
+version = "0.18.0"
+dependencies = [
+ "chrono",
+ "flate2",
+ "raphtory",
+]
+
 [[package]]
 name = "socket2"
 version = "0.5.10"
@@ -7977,12 +7593,12 @@ dependencies = [
 
 [[package]]
 name = "socket2"
-version = "0.6.1"
+version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17129e116933cf371d018bb80ae557e889637989d8638274fb25622827b03881"
+checksum = "3a766e1110788c36f4fa1c2b71b387a7815aa65f88ce0229841826633d93723e"
 dependencies = [
  "libc",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -8007,18 +7623,16 @@ version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
 dependencies = [
- "base64ct",
  "der",
 ]
 
 [[package]]
 name = "sqlparser"
-version = "0.58.0"
+version = "0.59.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec4b661c54b1e4b603b37873a18c59920e4c51ea8ea2cf527d925424dbd4437c"
+checksum = "4591acadbcf52f0af60eafbb2c003232b2b4cd8de5f0e9437cb8b1b59046cc0f"
 dependencies = [
  "log",
- "recursive",
  "sqlparser_derive",
 ]
 
@@ -8030,7 +7644,7 @@ checksum = "da5fc6819faabb412da764b99d3b713bb55083c11e7e0c00144d386cd6a1939c"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -8039,19 +7653,6 @@ version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
 
-[[package]]
-name = "stacker"
-version = "0.1.22"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1f8b29fb42aafcea4edeeb6b2f2d7ecd0d969c48b4cf0d2e64aafc471dd6e59"
-dependencies = [
- "cc",
- "cfg-if",
- "libc",
- "psm",
- "windows-sys 0.59.0",
-]
-
 [[package]]
 name = "static_assertions"
 version = "1.1.0"
@@ -8119,7 +7720,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "rustversion",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -8131,7 +7732,7 @@ dependencies = [
  "heck 0.5.0",
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -8153,9 +7754,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.114"
+version = "2.0.117"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4d107df263a3013ef9b1879b0df87d706ff80f65a86ea879bd9c31f9b307c2a"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -8188,7 +7789,7 @@ checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -8220,7 +7821,7 @@ dependencies = [
  "levenshtein_automata",
  "log",
  "lru",
- "lz4_flex",
+ "lz4_flex 0.11.6",
  "measure_time 0.8.3",
  "memmap2",
  "num_cpus",
@@ -8273,7 +7874,7 @@ dependencies = [
  "levenshtein_automata",
  "log",
  "lru",
- "lz4_flex",
+ "lz4_flex 0.11.6",
  "measure_time 0.9.0",
  "memmap2",
  "once_cell",
@@ -8281,10 +7882,10 @@ dependencies = [
  "rayon",
  "regex",
  "rust-stemmers",
- "rustc-hash 2.1.1",
+ "rustc-hash 2.1.2",
  "serde",
  "serde_json",
- "sketches-ddsketch 0.3.0",
+ "sketches-ddsketch 0.3.1",
  "smallvec",
  "tantivy-bitpacker 0.8.0",
  "tantivy-columnar 0.5.0",
@@ -8294,7 +7895,7 @@ dependencies = [
  "tantivy-stacker 0.5.0",
  "tantivy-tokenizer-api 0.5.0",
  "tempfile",
- "thiserror 2.0.17",
+ "thiserror 2.0.18",
  "time",
  "uuid",
  "winapi",
@@ -8481,31 +8082,62 @@ checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
 
 [[package]]
 name = "target-lexicon"
-version = "0.13.4"
+version = "0.13.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1dd07eb858a2067e2f3c7155d54e929265c264e6f37efe3ee7a8d1b5a1dd0ba"
+checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
 
 [[package]]
 name = "tempfile"
-version = "3.24.0"
+version = "3.27.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "655da9c7eb6305c55742045d5a8d2037996d61d8de95806335c7c86ce0f82e9c"
+checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
 dependencies = [
  "fastrand",
- "getrandom 0.3.4",
+ "getrandom 0.4.2",
  "once_cell",
- "rustix 1.1.3",
+ "rustix 1.1.4",
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "termcolor"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755"
+dependencies = [
+ "winapi-util",
+]
+
 [[package]]
 name = "terminal_size"
-version = "0.4.3"
+version = "0.4.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60b8cb979cb11c32ce1603f8137b22262a9d131aaa5c37b5678025f22b8becd0"
+checksum = "230a1b821ccbd75b185820a1f1ff7b14d21da1e442e22c0863ea5f08771a8874"
 dependencies = [
- "rustix 1.1.3",
- "windows-sys 0.60.2",
+ "rustix 1.1.4",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "test-log"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37d53ac171c92a39e4769491c4b4dde7022c60042254b5fc044ae409d34a24d4"
+dependencies = [
+ "env_logger 0.11.10",
+ "test-log-macros",
+ "tracing-subscriber",
+]
+
+[[package]]
+name = "test-log-macros"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be35209fd0781c5401458ab66e4f98accf63553e8fae7425503e92fdd319783b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -8519,11 +8151,11 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "2.0.17"
+version = "2.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f63587ca0f12b72a0600bcba1d40081f830876000bb46dd2337a3051618f4fc8"
+checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4"
 dependencies = [
- "thiserror-impl 2.0.17",
+ "thiserror-impl 2.0.18",
 ]
 
 [[package]]
@@ -8534,18 +8166,18 @@ checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "2.0.17"
+version = "2.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ff15c8ecd7de3849db632e14d18d2571fa09dfc5ed93479bc4485c7a517c913"
+checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -8577,6 +8209,26 @@ dependencies = [
  "ordered-float 2.10.1",
 ]
 
+[[package]]
+name = "tikv-jemalloc-sys"
+version = "0.6.1+5.3.0-1-ge13ca993e8ccb9ba9847cc330696e02839f328f7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd8aa5b2ab86a2cefa406d889139c162cbb230092f7d1d7cbc1716405d852a3b"
+dependencies = [
+ "cc",
+ "libc",
+]
+
+[[package]]
+name = "tikv-jemallocator"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0359b4327f954e0567e69fb191cf1436617748813819c94b8cd4a431422d053a"
+dependencies = [
+ "libc",
+ "tikv-jemalloc-sys",
+]
+
 [[package]]
 name = "time"
 version = "0.3.47"
@@ -8619,9 +8271,9 @@ dependencies = [
 
 [[package]]
 name = "tinystr"
-version = "0.8.2"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42d3e9c45c09de15d06dd8acf5f4e0e399e85927b7f00711024eb7ae10fa4869"
+checksum = "c8323304221c2a851516f22236c5722a72eaa19749016521d6dff0824447d96d"
 dependencies = [
  "displaydoc",
  "zerovec",
@@ -8639,10 +8291,11 @@ dependencies = [
 
 [[package]]
 name = "tinyvec"
-version = "1.10.0"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfa5fdc3bce6191a1dbc8c02d5c8bffcf557bafa17c124c5264a458f1b0613fa"
+checksum = "3e61e67053d25a4e82c844e8424039d9745781b3fc4f32b8d55ed50f5f667ef3"
 dependencies = [
+ "serde_core",
  "tinyvec_macros",
 ]
 
@@ -8654,9 +8307,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "tokio"
-version = "1.49.0"
+version = "1.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72a2903cd7736441aac9df9d7688bd0ce48edccaadf181c3b90be801e81d3d86"
+checksum = "a91135f59b1cbf38c91e73cf3386fca9bb77915c45ce2771460c9d92f0f3d776"
 dependencies = [
  "bytes",
  "libc",
@@ -8664,30 +8317,21 @@ dependencies = [
  "parking_lot",
  "pin-project-lite",
  "signal-hook-registry",
- "socket2 0.6.1",
+ "socket2 0.6.3",
  "tokio-macros",
+ "tracing",
  "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "tokio-macros"
-version = "2.6.0"
+version = "2.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af407857209536a95c8e56f8231ef2c2e2aff839b22e07a1ffcbc617e9db9fa5"
+checksum = "385a6cb71ab9ab790c5fe8d67f1645e6c450a7ce006a33de03daa956cf70a496"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
-]
-
-[[package]]
-name = "tokio-rustls"
-version = "0.24.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081"
-dependencies = [
- "rustls 0.21.12",
- "tokio",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -8696,7 +8340,7 @@ version = "0.26.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1729aa945f29d91ba541258c8df89027d5792d85a8841fb65e8bf0f4ede4ef61"
 dependencies = [
- "rustls 0.23.36",
+ "rustls",
  "tokio",
 ]
 
@@ -8760,9 +8404,9 @@ dependencies = [
 
 [[package]]
 name = "toml_datetime"
-version = "0.7.5+spec-1.1.0"
+version = "1.1.1+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "92e1cfed4a3038bc5a127e35a2d360f145e1f4b971b551a2ba5fd7aedf7e1347"
+checksum = "3165f65f62e28e0115a00b2ebdd37eb6f3b641855f9d636d3cd4103767159ad7"
 dependencies = [
  "serde_core",
 ]
@@ -8773,33 +8417,33 @@ version = "0.22.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a"
 dependencies = [
- "indexmap 2.13.0",
+ "indexmap 2.14.0",
  "serde",
  "serde_spanned",
  "toml_datetime 0.6.11",
  "toml_write",
- "winnow",
+ "winnow 0.7.15",
 ]
 
 [[package]]
 name = "toml_edit"
-version = "0.23.10+spec-1.0.0"
+version = "0.25.11+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84c8b9f757e028cee9fa244aea147aab2a9ec09d5325a9b01e0a49730c2b5269"
+checksum = "0b59c4d22ed448339746c59b905d24568fcbb3ab65a500494f7b8c3e97739f2b"
 dependencies = [
- "indexmap 2.13.0",
- "toml_datetime 0.7.5+spec-1.1.0",
+ "indexmap 2.14.0",
+ "toml_datetime 1.1.1+spec-1.1.0",
  "toml_parser",
- "winnow",
+ "winnow 1.0.1",
 ]
 
 [[package]]
 name = "toml_parser"
-version = "1.0.6+spec-1.1.0"
+version = "1.1.2+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3198b4b0a8e11f09dd03e133c0280504d0801269e9afa46362ffde1cbeebf44"
+checksum = "a2abe9b86193656635d2411dc43050282ca48aa31c2451210f4202550afb7526"
 dependencies = [
- "winnow",
+ "winnow 1.0.1",
 ]
 
 [[package]]
@@ -8819,16 +8463,16 @@ dependencies = [
  "axum 0.7.9",
  "base64 0.22.1",
  "bytes",
- "h2 0.4.13",
- "http 1.4.0",
- "http-body 1.0.1",
+ "h2",
+ "http",
+ "http-body",
  "http-body-util",
- "hyper 1.8.1",
+ "hyper",
  "hyper-timeout",
  "hyper-util",
  "percent-encoding",
  "pin-project",
- "prost",
+ "prost 0.13.5",
  "socket2 0.5.10",
  "tokio",
  "tokio-stream",
@@ -8885,8 +8529,8 @@ dependencies = [
  "bytes",
  "futures-core",
  "futures-util",
- "http 1.4.0",
- "http-body 1.0.1",
+ "http",
+ "http-body",
  "http-body-util",
  "iri-string",
  "pin-project-lite",
@@ -8929,7 +8573,7 @@ checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -8973,9 +8617,9 @@ dependencies = [
 
 [[package]]
 name = "tracing-subscriber"
-version = "0.3.22"
+version = "0.3.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f30143827ddab0d256fd843b7a66d164e9f271cfa0dde49142c5ca0ca291f1e"
+checksum = "cb7f578e5945fb242538965c2d0b04418d38ec25c79d160cd279bf0731c8d319"
 dependencies = [
  "matchers",
  "nu-ansi-term",
@@ -8989,6 +8633,27 @@ dependencies = [
  "tracing-log",
 ]
 
+[[package]]
+name = "tracing-test"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19a4c448db514d4f24c5ddb9f73f2ee71bfb24c526cf0c570ba142d1119e0051"
+dependencies = [
+ "tracing-core",
+ "tracing-subscriber",
+ "tracing-test-macro",
+]
+
+[[package]]
+name = "tracing-test-macro"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad06847b7afb65c7866a36664b75c40b895e318cea4f71299f013fb22965329d"
+dependencies = [
+ "quote",
+ "syn 2.0.117",
+]
+
 [[package]]
 name = "try-lock"
 version = "0.2.5"
@@ -9003,12 +8668,12 @@ checksum = "eadc29d668c91fcc564941132e17b28a7ceb2f3ebf0b9dae3e03fd7a6748eb0d"
 dependencies = [
  "bytes",
  "data-encoding",
- "http 1.4.0",
+ "http",
  "httparse",
  "log",
- "rand 0.9.2",
+ "rand 0.9.4",
  "sha1",
- "thiserror 2.0.17",
+ "thiserror 2.0.18",
  "utf-8",
 ]
 
@@ -9018,7 +8683,7 @@ version = "2.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9ea3136b675547379c4bd395ca6b938e5ad3c3d20fad76e7fe85f9e0d011419c"
 dependencies = [
- "rand 0.9.2",
+ "rand 0.9.4",
 ]
 
 [[package]]
@@ -9056,15 +8721,21 @@ checksum = "dbc4bc3a9f746d862c45cb89d705aa10f187bb96c76001afab07a0d35ce60142"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.22"
+version = "1.0.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
 
 [[package]]
 name = "unicode-segmentation"
-version = "1.12.0"
+version = "1.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
+checksum = "9629274872b2bfaf8d66f5f15725007f635594914870f65218920345aa11aa8c"
+
+[[package]]
+name = "unicode-width"
+version = "0.1.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"
 
 [[package]]
 name = "unicode-width"
@@ -9072,6 +8743,12 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
 
+[[package]]
+name = "unicode-xid"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
+
 [[package]]
 name = "unindent"
 version = "0.2.4"
@@ -9090,6 +8767,12 @@ version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
 
+[[package]]
+name = "unty"
+version = "0.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d49784317cd0d1ee7ec5c716dd598ec5b4483ea832a2dced265471cc0f690ae"
+
 [[package]]
 name = "url"
 version = "2.5.8"
@@ -9102,12 +8785,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "urlencoding"
-version = "2.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da"
-
 [[package]]
 name = "utf-8"
 version = "0.7.6"
@@ -9134,11 +8811,11 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
 [[package]]
 name = "uuid"
-version = "1.19.0"
+version = "1.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2e054861b4bd027cd373e18e8d8d8e6548085000e41290d95ce0c373a654b4a"
+checksum = "5ac8b6f42ead25368cf5b098aeb3dc8a1a2c05a3eee8a9a1a68c640edbfc79d9"
 dependencies = [
- "getrandom 0.3.4",
+ "getrandom 0.4.2",
  "js-sys",
  "serde_core",
  "wasm-bindgen",
@@ -9157,10 +8834,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
 [[package]]
-name = "vsimd"
-version = "0.8.0"
+name = "virtue"
+version = "0.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c3082ca00d5a5ef149bb8b555a72ae84c9c59f7250f013ac822ac2e49b19c64"
+checksum = "051eb1abcf10076295e815102942cc58f9d5e3b4560e46e53c21e8ff6f3af7b1"
 
 [[package]]
 name = "wait-timeout"
@@ -9198,18 +8875,27 @@ checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
 
 [[package]]
 name = "wasip2"
-version = "1.0.1+wasi-0.2.4"
+version = "1.0.2+wasi-0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasip3"
+version = "0.4.0+wasi-0.3.0-rc-2026-01-06"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7"
+checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5"
 dependencies = [
  "wit-bindgen",
 ]
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.106"
+version = "0.2.118"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d759f433fa64a2d763d1340820e46e111a7a5ab75f993d1852d70b03dbb80fd"
+checksum = "0bf938a0bacb0469e83c1e148908bd7d5a6010354cf4fb73279b7447422e3a89"
 dependencies = [
  "cfg-if",
  "once_cell",
@@ -9220,22 +8906,19 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.56"
+version = "0.4.68"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "836d9622d604feee9e5de25ac10e3ea5f2d65b41eac0d9ce72eb5deae707ce7c"
+checksum = "f371d383f2fb139252e0bfac3b81b265689bf45b6874af544ffa4c975ac1ebf8"
 dependencies = [
- "cfg-if",
  "js-sys",
- "once_cell",
  "wasm-bindgen",
- "web-sys",
 ]
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.106"
+version = "0.2.118"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48cb0d2638f8baedbc542ed444afc0644a29166f1595371af4fecf8ce1e7eeb3"
+checksum = "eeff24f84126c0ec2db7a449f0c2ec963c6a49efe0698c4242929da037ca28ed"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -9243,26 +8926,48 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.106"
+version = "0.2.118"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cefb59d5cd5f92d9dcf80e4683949f15ca4b511f4ac0a6e14d4e1ac60c6ecd40"
+checksum = "9d08065faf983b2b80a79fd87d8254c409281cf7de75fc4b773019824196c904"
 dependencies = [
  "bumpalo",
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.106"
+version = "0.2.118"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cbc538057e648b67f72a982e708d485b2efa771e1ac05fec311f9f63e5800db4"
+checksum = "5fd04d9e306f1907bd13c6361b5c6bfc7b3b3c095ed3f8a9246390f8dbdee129"
 dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "wasm-encoder"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319"
+dependencies = [
+ "leb128fmt",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasm-metadata"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909"
+dependencies = [
+ "anyhow",
+ "indexmap 2.14.0",
+ "wasm-encoder",
+ "wasmparser",
+]
+
 [[package]]
 name = "wasm-streams"
 version = "0.4.2"
@@ -9276,11 +8981,23 @@ dependencies = [
  "web-sys",
 ]
 
+[[package]]
+name = "wasmparser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"
+dependencies = [
+ "bitflags",
+ "hashbrown 0.15.5",
+ "indexmap 2.14.0",
+ "semver",
+]
+
 [[package]]
 name = "web-sys"
-version = "0.3.83"
+version = "0.3.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b32828d774c412041098d182a8b38b16ea816958e07cf40eec2bc080ae137ac"
+checksum = "4f2dfbb17949fa2088e5d39408c48368947b86f7834484e87b73de55bc14d97d"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -9302,14 +9019,14 @@ version = "0.26.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9"
 dependencies = [
- "webpki-roots 1.0.5",
+ "webpki-roots 1.0.6",
 ]
 
 [[package]]
 name = "webpki-roots"
-version = "1.0.5"
+version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12bed680863276c63889429bfd6cab3b99943659923822de1c8a39c49e4d722c"
+checksum = "22cfaf3c063993ff62e73cb4311efde4db1efb31ab78a3e5c457939ad5cc0bed"
 dependencies = [
  "rustls-pki-types",
 ]
@@ -9372,7 +9089,7 @@ checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -9383,7 +9100,7 @@ checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -9577,24 +9294,115 @@ checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
 
 [[package]]
 name = "winnow"
-version = "0.7.14"
+version = "0.7.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "winnow"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a5364e9d77fcdeeaa6062ced926ee3381faa2ee02d3eb83a5c27a8825540829"
+checksum = "09dac053f1cd375980747450bfc7250c264eaae0583872e845c0c7cd578872b5"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
 name = "wit-bindgen"
-version = "0.46.0"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
+dependencies = [
+ "wit-bindgen-rust-macro",
+]
+
+[[package]]
+name = "wit-bindgen-core"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc"
+dependencies = [
+ "anyhow",
+ "heck 0.5.0",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-bindgen-rust"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21"
+dependencies = [
+ "anyhow",
+ "heck 0.5.0",
+ "indexmap 2.14.0",
+ "prettyplease",
+ "syn 2.0.117",
+ "wasm-metadata",
+ "wit-bindgen-core",
+ "wit-component",
+]
+
+[[package]]
+name = "wit-bindgen-rust-macro"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a"
+dependencies = [
+ "anyhow",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "wit-bindgen-core",
+ "wit-bindgen-rust",
+]
+
+[[package]]
+name = "wit-component"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"
+dependencies = [
+ "anyhow",
+ "bitflags",
+ "indexmap 2.14.0",
+ "log",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "wasm-encoder",
+ "wasm-metadata",
+ "wasmparser",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-parser"
+version = "0.244.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59"
+checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736"
+dependencies = [
+ "anyhow",
+ "id-arena",
+ "indexmap 2.14.0",
+ "log",
+ "semver",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "unicode-xid",
+ "wasmparser",
+]
 
 [[package]]
 name = "writeable"
-version = "0.6.2"
+version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9"
+checksum = "1ffae5123b2d3fc086436f8834ae3ab053a283cfac8fe0a0b8eaae044768a4c4"
 
 [[package]]
 name = "wyz"
@@ -9605,12 +9413,6 @@ dependencies = [
  "tap",
 ]
 
-[[package]]
-name = "xmlparser"
-version = "0.13.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "66fee0b777b0f5ac1c69bb06d361268faafa61cd4682ae064a171c16c433e9e4"
-
 [[package]]
 name = "xxhash-rust"
 version = "0.8.15"
@@ -9645,9 +9447,9 @@ checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049"
 
 [[package]]
 name = "yoke"
-version = "0.8.1"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72d6e5c6afb84d73944e5cedb052c4680d5657337201555f9f2a16b7406d4954"
+checksum = "abe8c5fda708d9ca3df187cae8bfb9ceda00dd96231bed36e445a1a48e66f9ca"
 dependencies = [
  "stable_deref_trait",
  "yoke-derive",
@@ -9656,54 +9458,54 @@ dependencies = [
 
 [[package]]
 name = "yoke-derive"
-version = "0.8.1"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d"
+checksum = "de844c262c8848816172cef550288e7dc6c7b7814b4ee56b3e1553f275f1858e"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
  "synstructure",
 ]
 
 [[package]]
 name = "zerocopy"
-version = "0.8.33"
+version = "0.8.48"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "668f5168d10b9ee831de31933dc111a459c97ec93225beb307aed970d1372dfd"
+checksum = "eed437bf9d6692032087e337407a86f04cd8d6a16a37199ed57949d415bd68e9"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.33"
+version = "0.8.48"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c7962b26b0a8685668b671ee4b54d007a67d4eaf05fda79ac0ecf41e32270f1"
+checksum = "70e3cd084b1788766f53af483dd21f93881ff30d7320490ec3ef7526d203bad4"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
 name = "zerofrom"
-version = "0.1.6"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
+checksum = "69faa1f2a1ea75661980b013019ed6687ed0e83d069bc1114e2cc74c6c04c4df"
 dependencies = [
  "zerofrom-derive",
 ]
 
 [[package]]
 name = "zerofrom-derive"
-version = "0.1.6"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
+checksum = "11532158c46691caf0f2593ea8358fed6bbf68a0315e80aae9bd41fbade684a1"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
  "synstructure",
 ]
 
@@ -9724,14 +9526,14 @@ checksum = "85a5b4158499876c763cb03bc4e49185d3cccbabb15b33c627f7884f43db852e"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
 name = "zerotrie"
-version = "0.2.3"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a59c17a5562d507e4b54960e8569ebee33bee890c70aa3fe7b97e85a9fd7851"
+checksum = "0f9152d31db0792fa83f70fb2f83148effb5c1f5b8c7686c3459e361d9bc20bf"
 dependencies = [
  "displaydoc",
  "yoke",
@@ -9740,9 +9542,9 @@ dependencies = [
 
 [[package]]
 name = "zerovec"
-version = "0.11.5"
+version = "0.11.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c28719294829477f525be0186d13efa9a3c602f7ec202ca9e353d310fb9a002"
+checksum = "90f911cbc359ab6af17377d242225f4d75119aec87ea711a880987b18cd7b239"
 dependencies = [
  "yoke",
  "zerofrom",
@@ -9751,13 +9553,13 @@ dependencies = [
 
 [[package]]
 name = "zerovec-derive"
-version = "0.11.2"
+version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3"
+checksum = "625dc425cab0dca6dc3c3319506e6593dcb08a9f387ea3b284dbd52a92c40555"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -9777,12 +9579,12 @@ dependencies = [
  "flate2",
  "getrandom 0.3.4",
  "hmac",
- "indexmap 2.13.0",
+ "indexmap 2.14.0",
  "lzma-rs",
  "memchr",
  "pbkdf2",
  "sha1",
- "thiserror 2.0.17",
+ "thiserror 2.0.18",
  "time",
  "xz2",
  "zeroize",
@@ -9792,15 +9594,15 @@ dependencies = [
 
 [[package]]
 name = "zlib-rs"
-version = "0.5.5"
+version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40990edd51aae2c2b6907af74ffb635029d5788228222c4bb811e9351c0caad3"
+checksum = "3be3d40e40a133f9c916ee3f9f4fa2d9d63435b5fbe1bfc6d9dae0aa0ada1513"
 
 [[package]]
 name = "zmij"
-version = "1.0.14"
+version = "1.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd8f3f50b848df28f887acb68e41201b5aea6bc8a8dacc00fb40635ff9a72fea"
+checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
 
 [[package]]
 name = "zopfli"
diff --git a/Cargo.toml b/Cargo.toml
index 6ae4198d63..eb7e7e59a9 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,18 +1,25 @@
 [workspace]
 members = [
     "raphtory",
-    "raphtory-cypher",
     "raphtory-benchmark",
     "examples/rust",
     "examples/netflow",
     "examples/custom-gql-apis",
     "python",
     "raphtory-graphql",
+    "raphtory-auth-noop",
+    "raphtory-server",
     "raphtory-api",
     "raphtory-core",
     "raphtory-storage",
+    "raphtory-api-macros",
+    "raphtory-itertools",
+    "clam-core",
+    "clam-core/snb",
+    "raphtory-itertools"
 ]
 default-members = ["raphtory"]
+exclude = ["optd"]
 resolver = "2"
 
 [workspace.package]
@@ -30,7 +37,8 @@ edition = "2021"
 # debug symbols are using a lot of resources
 [profile.dev]
 split-debuginfo = "unpacked"
-debug = true
+debug = 1
+opt-level = 1
 
 [profile.release-with-debug]
 inherits = "release"
@@ -46,138 +54,158 @@ debug = true
 inherits = "dev"
 debug = false
 incremental = false
+opt-level = 1 # much smaller files
 
 
 [workspace.dependencies]
-#[public-storage]
-pometry-storage = { version = ">=0.8.1", path = "pometry-storage" }
-#[private-storage]
-# pometry-storage = { path = "pometry-storage-private", package = "pometry-storage-private" }
-raphtory = { path = "raphtory", version = "0.18.0" }
-raphtory-api = { path = "raphtory-api", version = "0.18.0" }
-raphtory-core = { path = "raphtory-core", version = "0.18.0" }
-raphtory-storage = { path = "raphtory-storage", version = "0.18.0" }
-raphtory-graphql = { path = "raphtory-graphql", version = "0.18.0" }
-async-graphql = { version = "7.0.16", features = ["dynamic-schema"] }
-bincode = "1.3.3"
-async-graphql-poem = "7.0.16"
-dynamic-graphql = "0.10.1"
+db4-graph = { version = "0.18.0", path = "db4-graph", default-features = false }
+db4-storage = { version = "0.18.0", path = "db4-storage" }
+raphtory = { version = "0.18.0", path = "raphtory", default-features = false }
+raphtory-api = { version = "0.18.0", path = "raphtory-api", default-features = false }
+raphtory-api-macros = { version = "0.18.0", path = "raphtory-api-macros", default-features = false }
+raphtory-core = { version = "0.18.0", path = "raphtory-core", default-features = false }
+raphtory-graphql = { version = "0.18.0", path = "raphtory-graphql", default-features = false }
+raphtory-storage = { version = "0.18.0", path = "raphtory-storage", default-features = false }
+raphtory-itertools = { version = "0.18.0", path = "raphtory-itertools" }
+clam-core = { version = "0.18.0", path = "clam-core" }
+optd-core = { version = "0.18.0", path = "optd/optd/core" }
+async-graphql = { version = "7.2.1", features = ["dynamic-schema"] }
+bincode = { version = "2", features = ["serde"] }
+async-graphql-poem = "7.2.1"
+dynamic-graphql = { git = "https://github.com/miratepuffin/dynamic-graphql", branch = "add-arg-descriptions" }
+derive_more = "2.1.1"
+tikv-jemallocator = "0.6.1"
 reqwest = { version = "0.12.28", default-features = false, features = [
     "rustls-tls",
     "multipart",
     "json",
 ] }
-iter-enum = { version = "1.2.0", features = ["rayon"] }
-serde = { version = "1.0.197", features = ["derive", "rc"] }
-serde_json = "1.0.114"
-pyo3 = { version = "0.25.1", features = ["multiple-pymethods", "chrono"] }
-pyo3-build-config = "0.25.1"
-pyo3-arrow = "0.11.0"
-numpy = "0.25.0"
+boxcar = "0.2.14"
+iter-enum = { version = "1.2.1", features = ["rayon"] }
+serde = { version = "1.0.228", features = ["derive", "rc"] }
+serde_json = { version = "1.0.149", features = ["float_roundtrip"] }
+pyo3 = { version = "0.27.2", features = ["multiple-pymethods", "chrono"] }
+pyo3-build-config = "0.27.2"
+pyo3-arrow = "0.15.0"
+numpy = "0.27.1"
 itertools = "0.13.0"
-rand = "0.8.5"
-rayon = "1.8.1"
-roaring = "0.10.6"
+rand = "0.9.2"
+rayon = "1.11.0"
+roaring = "0.10.12"
 sorted_vector_map = "0.2.0"
-tokio = { version = "1.43.1", features = ["full"] }
-once_cell = "1.19.0"
-parking_lot = { version = "0.12.1", features = [
+tokio = { version = "1.50.0", features = ["full"] }
+once_cell = "1.21.4"
+parking_lot = { version = "0.12.5", features = [
     "serde",
     "arc_lock",
     "send_guard",
 ] }
-ordered-float = "4.2.0"
-chrono = { version = "0.4.41", features = ["serde"] }
-tempfile = "3.10.0"
-futures-util = "0.3.30"
-thiserror = "2.0.0"
+ordered-float = "4.6.0"
+chrono = { version = "0.4.44", features = ["serde"] }
+chrono-tz = "0.10.4"
+tempfile = "3.27.0"
+futures-util = "0.3.32"
+thiserror = "2.0.18"
 dotenv = "0.15.0"
-csv = "1.3.0"
-flate2 = "1.0.28"
-regex = "1.10.3"
-num-traits = "0.2.18"
+csv = "1.4.0"
+flate2 = "1.1.9"
+regex = "1.12.3"
+num-traits = "0.2.19"
 num-integer = "0.1"
-rand_distr = "0.4.3"
-rustc-hash = "2.0.0"
-twox-hash = "2.1.0"
-lock_api = { version = "0.4.11", features = ["arc_lock", "serde"] }
-dashmap = { version = "6.0.1", features = ["serde", "rayon"] }
-glam = "0.29.0"
-quad-rand = "0.2.1"
-zip = "2.3.0"
+rand_distr = "0.5.1"
+rustc-hash = "2.1.1"
+twox-hash = "2.1.2"
+tinyvec = { version = "1.11", features = ["serde", "alloc"] }
+lock_api = { version = "0.4.14", features = ["arc_lock", "serde"] }
+dashmap = { version = "6.1.0", features = ["serde", "rayon"] }
+glam = "0.29.3"
+quad-rand = "0.2.3"
+zip = "2.4.2"
 neo4rs = "0.8.0"
 bzip2 = "0.4.4"
 tantivy = "0.22.1"
-async-trait = "0.1.77"
+async-trait = "0.1.89"
 async-openai = "0.28.3"
-num = "0.4.1"
-display-error-chain = "0.2.0"
-bigdecimal = { version = "0.4.7", features = ["serde"] }
-kdam = "0.6.3"
-hashbrown = "0.15.1"
-pretty_assertions = "1.4.0"
-quickcheck = "1.0.3"
-quickcheck_macros = "1.0.0"
+num = "0.4.3"
+display-error-chain = "0.2.2"
+bigdecimal = { version = "0.4.10", features = ["serde"] }
+kdam = "0.6.4"
+hashbrown = { version = "0.14.5", features = ["raw"] }
+pretty_assertions = "1.4.1"
 streaming-stats = "0.2.3"
-proptest = "1.4.0"
-proptest-derive = "0.5.1"
+proptest = "1.11.0"
+proptest-derive = "0.6.0"
 criterion = "0.5.1"
 crossbeam-channel = "0.5.15"
 base64 = "0.22.1"
 jsonwebtoken = { version = "10.3.0", features = ["aws_lc_rs"] }
 spki = "0.7.3"
-poem = { version = "3.0.1", features = ["compression", "embed", "static-files"] }
-rust-embed = { version = "8.7.2", features = ["interpolate-folder-path"] }
+poem = { version = "3.1.12", features = ["compression", "embed", "static-files"] }
+rust-embed = { version = "8.11.0", features = ["interpolate-folder-path"] }
 opentelemetry = "0.27.1"
 opentelemetry_sdk = { version = "0.27.1", features = ["rt-tokio"] }
 opentelemetry-otlp = { version = "0.27.0" }
-tracing = "0.1.37"
+tracing = { version = "0.1.44", features = ["log"] }
 tracing-opentelemetry = "0.28.0"
-tracing-subscriber = { version = "0.3.20", features = ["std", "env-filter"] }
-indoc = "2.0.5"
+tracing-subscriber = { version = "0.3.23", features = ["std", "env-filter"] }
+indoc = "2.0.7"
 walkdir = "2"
-config = "0.14.0"
+config = "0.14.1"
 either = "=1.15.0"
-clap = { version = "4.5.21", features = ["derive", "env"] }
-memmap2 = { version = "0.9.4" }
-ahash = { version = "0.8.3", features = ["serde"] }
-bytemuck = { version = "1.18.0", features = ["derive"] }
-ouroboros = "0.18.3"
-url = "2.2"
+clap = { version = "4.6.0", features = ["derive", "env"] }
+memmap2 = { version = "0.9.10" }
+ahash = { version = "0.8.12", features = ["serde"] }
+bytemuck = { version = "1.25.0", features = ["derive"] }
+ouroboros = "0.18.5"
+url = "2.5"
 base64-compat = { package = "base64-compat", version = "1.0.0" }
-prost = "0.13.1"
-prost-types = "0.13.1"
-prost-build = "0.13.1"
-lazy_static = "1.4.0"
-pest = "2.7.8"
-pest_derive = "2.7.8"
-minijinja = "2.2.0"
-minijinja-contrib = { version = "2.2.0", features = ["datetime"] }
-datafusion = { version = "50.0.0" }
-lancedb = { version = "0.22.2", features = [] } # this is the latest and asks for chrono 0.4.41
+prost = "0.13.5"
+prost-types = "0.13.5"
+prost-build = "0.13.5"
+lazy_static = "1.5.0"
+pest = "2.8.6"
+pest_derive = "2.8.6"
+minijinja = "2.18.0"
+minijinja-contrib = { version = "2.18.0", features = ["datetime"] }
+
+lancedb = { version = "0.27.2", features = [] }
 heed = "0.22.0"
-sqlparser = "0.58.0"
+sqlparser = "0.59.0"
 futures = "0.3"
-arrow = { version = "56.2.0" }
-parquet = { version = "56.2.0" }
-arrow-json = { version = "56.2.0" }
-arrow-buffer = { version = "56.2.0" }
-arrow-schema = { version = "56.2.0" }
-arrow-csv = { version = "56.2.0" }
-arrow-array = { version = "56.2.0", features = ["chrono-tz"] }
-arrow-cast = { version = "56.2.0" }
-arrow-ipc = { version = "56.2.0" }
-arrow-data = { version = "56.2.0" }
-arrow-select = { version = "56.2.0" }
-serde_arrow = { version = "0.13.0" }
-moka = { version = "0.12.7", features = ["future"] }
-indexmap = { version = "2.7.0", features = ["rayon"] }
+arrow = { version = "57.3.0" }
+parquet = { version = "57.3.0" }
+arrow-json = { version = "57.3.0" }
+arrow-buffer = { version = "57.3.0" }
+arrow-schema = { version = "57.3.0" }
+arrow-csv = { version = "57.3.0" }
+arrow-array = { version = "57.3.0", features = ["chrono-tz"] }
+arrow-cast = { version = "57.3.0" }
+arrow-ipc = { version = "57.3.0" }
+arrow-data = { version = "57.3.0" }
+arrow-select = { version = "57.3.0" }
+serde_arrow = { version = "0.13.7", features = ["arrow-57"] }
+moka = { version = "0.12.15", features = ["future"] }
+indexmap = { version = "2.13.0", features = ["rayon"] }
 fake = { version = "3.1.0", features = ["chrono"] }
 strsim = { version = "0.11.1" }
-uuid = { version = "1.16.0", features = ["v4"] }
+uuid = { version = "1.22.0", features = ["v4"] }
+bitvec = "1.0.1"
+sysinfo = "0.37.2"
 strum = "0.27.2"
 strum_macros = "0.27.2"
-datafusion-physical-expr-common = "50.3.0"
-datafusion-physical-expr = "50.3.0"
-datafusion-physical-plan = "50.3.0"
-datafusion-expr-common = "50.3.0"
+pythonize = { version = "0.27.0" }
+test-log = "0.2.19"
+disjoint-sets = "0.4.2"
+datafusion = { version = "52.5.0" }
+datafusion-physical-expr-common = "52.5.0"
+datafusion-physical-expr = "52.5.0"
+datafusion-physical-plan = "52.5.0"
+datafusion-expr-common = "52.5.0"
+
+[workspace.dependencies.storage]
+package = "db4-storage"
+path = "db4-storage"
+
+[workspace.dependencies.auth]
+package = "raphtory-auth-noop"
+path = "raphtory-auth-noop"
diff --git a/Dockerfile b/Dockerfile
index 21dd104bc4..736edc4261 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,4 +1,4 @@
-ARG RUST_VERSION=1.86.0
+ARG RUST_VERSION=1.89.0
 ARG RAPHTORY_PROFILE="release"
 
 FROM rust:${RUST_VERSION} AS chef
diff --git a/Makefile b/Makefile
index f1170a349c..53b85fa83e 100644
--- a/Makefile
+++ b/Makefile
@@ -12,17 +12,13 @@ build-all: rust-build
 
 test-all: rust-test-all python-test
 
-test-all-public: rust-test-all-public python-test-public
-
 # Tidying
 
 tidy: rust-fmt build-python stubs python-fmt
 
-tidy-public: rust-fmt build-python-public stubs python-fmt
-
 python-tidy: stubs python-fmt test-graphql-schema
 
-check-pr: tidy-public test-all
+check-pr: tidy test-all
 
 gen-graphql-schema:
 	raphtory schema > raphtory-graphql/schema.graphql
@@ -31,7 +27,6 @@ test-graphql-schema: install-node-tools
 	npx graphql-schema-linter --rules fields-have-descriptions,types-have-descriptions raphtory-graphql/schema.graphql
 
 # Utilities
-
 activate-storage:
 	./scripts/activate_private_storage.py
 
@@ -41,8 +36,10 @@ deactivate-storage:
 pull-storage: activate-storage
 	git submodule update --init --recursive pometry-storage-private
 
-pull-ui-tests:
-	git submodule update --init --recursive ui-tests
+update-ui-tests:
+	rm -rf ui-tests
+	git clone git@github.com:Pometry/ui-tests.git ui-tests
+	rm -rf ui-tests/.git
 
 install-node-tools:
 	@if command -v npx >/dev/null 2>&1; then \
@@ -71,13 +68,12 @@ run-graphql:
 rust-test:
 	cargo test -q
 
-rust-test-all: activate-storage
-	cargo nextest run --all --features=storage
+rust-check:
 	cargo hack check --workspace --all-targets --each-feature  --skip extension-module,default
 
-rust-test-all-public:
+rust-test-all: rust-check
 	cargo nextest run --all
-	cargo hack check --workspace --all-targets --each-feature  --skip extension-module,default,storage
+
 
 ##########
 # Python #
@@ -92,32 +88,23 @@ clean:
 install-python: build-wheel
 	pip install target/wheels/*.whl
 
-build-python-public: deactivate-storage
+build-python:
 	cd python && maturin develop -r --extras=dev
 
-build-python: activate-storage
-	cd python && maturin develop -r --features=storage,extension-module --extras=dev
+debug-python:
+	cd python && maturin develop --profile=dev --extras=dev
 
 # Testing
-
-python-test: activate-storage
-	cd python && tox run && tox run -e storage
-
-python-test-public:
+python-test:
 	cd python && tox run
 
 python-fmt:
 	cd python && black .
 
-debug-python-public: deactivate-storage
-	cd python && maturin develop --profile=dev
 
 build-python-rtd:
 	cd python && maturin build --profile=build-fast && pip install ../target/wheels/*.whl
 
-debug-python: activate-storage
-	cd python && maturin develop --features=storage,extension-module --extras=dev
-
 ########
 # Docs #
 ########
diff --git a/clam-core b/clam-core
new file mode 160000
index 0000000000..9f86d6e4a0
--- /dev/null
+++ b/clam-core
@@ -0,0 +1 @@
+Subproject commit 9f86d6e4a0a74b41bf71b316e34f614fb33609ce
diff --git a/pometry-storage/Cargo.toml b/db4-graph/Cargo.toml
similarity index 65%
rename from pometry-storage/Cargo.toml
rename to db4-graph/Cargo.toml
index 1d7ae0a0ba..544912f0de 100644
--- a/pometry-storage/Cargo.toml
+++ b/db4-graph/Cargo.toml
@@ -1,16 +1,18 @@
 [package]
-name = "pometry-storage"
-description = "Storage backend for Raphtory"
-edition.workspace = true
-rust-version.workspace = true
+name = "db4-graph"
 version.workspace = true
-keywords.workspace = true
-authors.workspace = true
 documentation.workspace = true
 repository.workspace = true
 license.workspace = true
 readme.workspace = true
 homepage.workspace = true
+keywords.workspace = true
+authors.workspace = true
+rust-version.workspace = true
+edition.workspace = true
 
-[features]
-storage = []
+[dependencies]
+storage.workspace = true
+raphtory-api.workspace = true
+raphtory-core.workspace = true
+rayon.workspace = true
diff --git a/db4-graph/src/lib.rs b/db4-graph/src/lib.rs
new file mode 100644
index 0000000000..4502f01feb
--- /dev/null
+++ b/db4-graph/src/lib.rs
@@ -0,0 +1,465 @@
+use raphtory_api::core::{
+    entities::{
+        self,
+        properties::meta::{Meta, STATIC_GRAPH_LAYER_ID},
+        GidType,
+    },
+    input::input_node::InputNode,
+    storage::timeindex::TimeIndexOps,
+};
+use raphtory_core::{
+    entities::{graph::tgraph::InvalidLayer, nodes::node_ref::NodeRef, GidRef, LayerIds, EID, VID},
+    storage::timeindex::EventTime,
+};
+use rayon::prelude::*;
+use std::{
+    ops::Deref,
+    path::Path,
+    sync::{atomic::AtomicUsize, Arc},
+};
+use storage::{
+    api::{
+        edges::EdgeSegmentOps,
+        graph_props::GraphPropSegmentOps,
+        nodes::{LockedNSSegment, NodeRefOps, NodeSegmentOps},
+    },
+    dir::GraphDir,
+    error::StorageError,
+    pages::{
+        layer_counter::GraphStats,
+        locked::{
+            edges::WriteLockedEdgePages, graph_props::WriteLockedGraphPropPages,
+            nodes::WriteLockedNodePages,
+        },
+    },
+    persist::strategy::PersistenceStrategy,
+    resolver::GIDResolverOps,
+    transaction::TransactionManager,
+    Config, Extension, GIDResolver, Layer, LocalPOS, ReadLockedLayer, ES, GS, NS,
+};
+
+mod replay;
+
+#[derive(Debug)]
+pub struct TemporalGraph<EXT = Extension>
+where
+    EXT: PersistenceStrategy<NS = NS<EXT>, ES = ES<EXT>, GS = GS<EXT>>,
+    NS<EXT>: NodeSegmentOps<Extension = EXT>,
+    ES<EXT>: EdgeSegmentOps<Extension = EXT>,
+    GS<EXT>: GraphPropSegmentOps<Extension = EXT>,
+{
+    // mapping between logical and physical ids
+    pub logical_to_physical: Arc<GIDResolver>,
+    pub round_robin_counter: AtomicUsize,
+    storage: Arc<Layer<EXT>>,
+    graph_dir: Option<GraphDir>,
+    pub transaction_manager: Arc<TransactionManager>,
+}
+
+impl Default for TemporalGraph<Extension> {
+    fn default() -> Self {
+        let config = Config::default();
+        let graph_dir = None;
+        Self::new(Extension::new(config, graph_dir).unwrap()).unwrap()
+    }
+}
+
+impl<EXT> TemporalGraph<EXT>
+where
+    EXT: PersistenceStrategy<NS = NS<EXT>, ES = ES<EXT>, GS = GS<EXT>>,
+    NS<EXT>: NodeSegmentOps<Extension = EXT>,
+    ES<EXT>: EdgeSegmentOps<Extension = EXT>,
+    GS<EXT>: GraphPropSegmentOps<Extension = EXT>,
+{
+    pub fn new(ext: EXT) -> Result<Self, StorageError> {
+        let node_meta = Meta::new_for_nodes();
+        let edge_meta = Meta::new_for_edges();
+        let graph_props_meta = Meta::new_for_graph_props();
+
+        Self::new_with_meta(None, node_meta, edge_meta, graph_props_meta, ext)
+    }
+
+    pub fn new_at_path_with_ext(path: impl AsRef<Path>, ext: EXT) -> Result<Self, StorageError> {
+        let node_meta = Meta::new_for_nodes();
+        let edge_meta = Meta::new_for_edges();
+        let graph_props_meta = Meta::new_for_graph_props();
+
+        Self::new_with_meta(
+            Some(path.as_ref().into()),
+            node_meta,
+            edge_meta,
+            graph_props_meta,
+            ext,
+        )
+    }
+
+    pub fn new_with_meta(
+        graph_dir: Option<GraphDir>,
+        node_meta: Meta,
+        edge_meta: Meta,
+        graph_meta: Meta,
+        ext: EXT,
+    ) -> Result<Self, StorageError> {
+        let mut graph_dir = graph_dir;
+
+        // Short-circuit graph_dir to None if disk storage is not enabled
+        if !Extension::disk_storage_enabled() {
+            graph_dir = None;
+        }
+
+        if let Some(dir) = graph_dir.as_ref() {
+            std::fs::create_dir_all(dir)?
+        }
+
+        let id_type = node_meta
+            .metadata_mapper()
+            .d_types()
+            .first()
+            .and_then(|dtype| GidType::from_prop_type(dtype));
+
+        let gid_resolver_dir = graph_dir.as_ref().map(|dir| dir.gid_resolver_dir());
+        let logical_to_physical = match gid_resolver_dir {
+            Some(gid_resolver_dir) => GIDResolver::new_with_path(gid_resolver_dir, id_type)?,
+            None => GIDResolver::new()?,
+        }
+        .into();
+
+        let storage: Layer<EXT> = Layer::new_with_meta(
+            graph_dir.as_ref().map(|p| p.path()),
+            node_meta,
+            edge_meta,
+            graph_meta,
+            ext,
+        );
+
+        Ok(Self {
+            graph_dir,
+            logical_to_physical,
+            storage: Arc::new(storage),
+            transaction_manager: Arc::new(TransactionManager::new()),
+            round_robin_counter: AtomicUsize::new(0),
+        })
+    }
+
+    pub fn load(path: impl AsRef<Path>, ext: EXT) -> Result<Self, StorageError> {
+        let path = path.as_ref();
+        let storage = Layer::load(path, ext)?;
+        let id_type = storage.nodes().id_type();
+
+        let gid_resolver_dir = path.join("gid_resolver");
+        let resolver = GIDResolver::new_with_path(&gid_resolver_dir, id_type)?;
+
+        Ok(Self {
+            graph_dir: Some(path.into()),
+            round_robin_counter: AtomicUsize::new(0),
+            logical_to_physical: resolver.into(),
+            storage: Arc::new(storage),
+            transaction_manager: Arc::new(TransactionManager::new()),
+        })
+    }
+
+    pub fn flush(&self) -> Result<(), StorageError> {
+        self.storage.flush()?;
+        self.logical_to_physical.flush()
+    }
+
+    pub fn disk_storage_path(&self) -> Option<&Path> {
+        self.graph_dir()
+            .filter(|_| Extension::disk_storage_enabled())
+    }
+
+    pub fn extension(&self) -> &EXT {
+        self.storage().extension()
+    }
+
+    pub fn read_event_counter(&self) -> usize {
+        self.storage().read_event_id()
+    }
+
+    pub fn storage(&self) -> &Arc<Layer<EXT>> {
+        &self.storage
+    }
+
+    pub fn num_layers(&self) -> usize {
+        self.storage.nodes().num_layers() - 1
+    }
+
+    #[inline]
+    pub fn resolve_node_ref(&self, node: NodeRef) -> Option<VID> {
+        let vid = match node {
+            NodeRef::Internal(vid) => Some(vid),
+            NodeRef::External(GidRef::U64(gid)) => self.logical_to_physical.get_u64(gid),
+            NodeRef::External(GidRef::Str(string)) => self
+                .logical_to_physical
+                .get_str(string)
+                .or_else(|| self.logical_to_physical.get_u64(string.id())),
+        }?;
+
+        // VIDs in the resolver may not be initialised yet, need to double-check the node actually exists!
+        let nodes = self.storage().nodes();
+        let (page_id, pos) = nodes.resolve_pos(vid);
+        let node_page = nodes.get_segment(page_id)?;
+
+        if pos.0 < node_page.num_nodes() {
+            Some(vid)
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    pub fn internal_num_nodes(&self, layer_ids: &LayerIds) -> usize {
+        match layer_ids {
+            LayerIds::None => self
+                .storage
+                .nodes()
+                .segments_par_iter()
+                .map(|segment| {
+                    let locked = segment.locked();
+                    locked
+                        .iter_entries()
+                        .filter(|entry| !entry.node_additions(STATIC_GRAPH_LAYER_ID).is_empty())
+                        .count()
+                })
+                .sum(),
+            LayerIds::All => self.storage.nodes().num_nodes(),
+            LayerIds::One(id) => self
+                .storage
+                .nodes()
+                .segments_par_iter()
+                .map(|segment| {
+                    let locked = segment.locked();
+                    locked
+                        .iter_entries()
+                        .filter(|entry| {
+                            !entry.node_additions(STATIC_GRAPH_LAYER_ID).is_empty()
+                                || entry.has_layer_inner(*id)
+                        })
+                        .count()
+                })
+                .sum(),
+            LayerIds::Multiple(ids) => {
+                // no fast path, need to count
+                self.storage
+                    .nodes()
+                    .segments_par_iter()
+                    .map(|segment| {
+                        let locked = segment.locked();
+                        locked
+                            .iter_entries()
+                            .filter(|entry| {
+                                !entry.node_additions(STATIC_GRAPH_LAYER_ID).is_empty()
+                                    || ids.iter().any(|layer| entry.has_layer_inner(layer))
+                            })
+                            .count()
+                    })
+                    .sum()
+            }
+        }
+    }
+
+    #[inline]
+    pub fn internal_num_edges(&self, layer_ids: &LayerIds) -> usize {
+        match layer_ids {
+            LayerIds::None => 0,
+            LayerIds::All => self.storage.edges().num_edges_layer(STATIC_GRAPH_LAYER_ID),
+            LayerIds::One(id) => self.storage.edges().num_edges_layer(*id),
+            LayerIds::Multiple(ids) => {
+                // no fast path, need to count
+                self.storage
+                    .edges()
+                    .par_iter_segments()
+                    .map(|segment| {
+                        let head = segment.head();
+                        (0..segment.num_edges())
+                            .map(LocalPOS)
+                            .filter(|pos| {
+                                ids.iter()
+                                    .any(|layer| segment.has_edge(*pos, layer, head.deref()))
+                            })
+                            .count()
+                    })
+                    .sum()
+            }
+        }
+    }
+
+    pub fn read_locked(self: &Arc<Self>) -> ReadLockedLayer<EXT> {
+        self.storage.read_locked()
+    }
+
+    pub fn edge_meta(&self) -> &Meta {
+        self.storage().edge_meta()
+    }
+
+    pub fn node_meta(&self) -> &Meta {
+        self.storage().node_meta()
+    }
+
+    pub fn graph_props_meta(&self) -> &Meta {
+        self.storage.graph_props_meta()
+    }
+
+    pub fn graph_dir(&self) -> Option<&Path> {
+        self.graph_dir.as_ref().map(|p| p.path())
+    }
+
+    #[inline]
+    pub fn graph_earliest_time(&self) -> Option<i64> {
+        Some(self.storage().earliest()).filter(|t| *t != i64::MAX)
+    }
+
+    #[inline]
+    pub fn graph_latest_time(&self) -> Option<i64> {
+        Some(self.storage().latest()).filter(|t| *t != i64::MIN)
+    }
+
+    pub fn layer_ids(&self, key: entities::Layer) -> Result<LayerIds, InvalidLayer> {
+        match key {
+            entities::Layer::None => Ok(LayerIds::None),
+            entities::Layer::All => Ok(LayerIds::All),
+            entities::Layer::Default => match self.edge_meta().get_default_layer_id() {
+                None => Ok(LayerIds::None),
+                Some(id) => Ok(LayerIds::One(id)),
+            },
+            entities::Layer::One(id) => match self.edge_meta().get_layer_id(&id) {
+                Some(id) => Ok(LayerIds::One(id)),
+                None => Err(InvalidLayer::new(
+                    id,
+                    Self::get_valid_layers(self.edge_meta()),
+                )),
+            },
+            entities::Layer::Multiple(ids) => {
+                let mut new_layers = ids
+                    .iter()
+                    .map(|id| {
+                        self.edge_meta().get_layer_id(id).ok_or_else(|| {
+                            InvalidLayer::new(id.clone(), Self::get_valid_layers(self.edge_meta()))
+                        })
+                    })
+                    .collect::<Result<Vec<_>, InvalidLayer>>()?;
+                let num_layers = self.num_layers();
+                let num_new_layers = new_layers.len();
+                if num_new_layers == 0 {
+                    Ok(LayerIds::None)
+                } else if num_new_layers == 1 {
+                    Ok(LayerIds::One(new_layers[0]))
+                } else if num_new_layers == num_layers {
+                    Ok(LayerIds::All)
+                } else {
+                    new_layers.sort_unstable();
+                    new_layers.dedup();
+                    Ok(LayerIds::Multiple(new_layers.into()))
+                }
+            }
+        }
+    }
+
+    fn get_valid_layers(edge_meta: &Meta) -> Vec<String> {
+        edge_meta
+            .layer_meta()
+            .keys()
+            .iter()
+            .map(|x| x.to_string())
+            .collect::<Vec<_>>()
+    }
+
+    pub fn valid_layer_ids(&self, key: entities::Layer) -> LayerIds {
+        match key {
+            entities::Layer::None => LayerIds::None,
+            entities::Layer::All => LayerIds::All,
+            entities::Layer::Default => match self.edge_meta().get_default_layer_id() {
+                None => LayerIds::None,
+                Some(id) => LayerIds::One(id),
+            },
+            entities::Layer::One(id) => match self.edge_meta().get_layer_id(&id) {
+                Some(id) => LayerIds::One(id),
+                None => LayerIds::None,
+            },
+            entities::Layer::Multiple(ids) => {
+                let mut new_layers = ids
+                    .iter()
+                    .flat_map(|id| self.edge_meta().get_layer_id(id))
+                    .collect::<Vec<_>>();
+                let num_layers = self.num_layers();
+                let num_new_layers = new_layers.len();
+                if num_new_layers == 0 {
+                    LayerIds::None
+                } else if num_new_layers == 1 {
+                    LayerIds::One(new_layers[0])
+                } else if num_new_layers == num_layers {
+                    LayerIds::All
+                } else {
+                    new_layers.sort_unstable();
+                    new_layers.dedup();
+                    LayerIds::Multiple(new_layers.into())
+                }
+            }
+        }
+    }
+
+    pub fn write_locked_graph<'a>(&'a self) -> WriteLockedGraph<'a, EXT> {
+        WriteLockedGraph::new(self)
+    }
+
+    pub fn update_time(&self, earliest: EventTime) {
+        // self.storage.update_time(earliest);
+    }
+}
+
+/// Holds write locks across all segments in the graph for fast bulk ingestion.
+pub struct WriteLockedGraph<'a, EXT>
+where
+    EXT: PersistenceStrategy<NS = NS<EXT>, ES = ES<EXT>, GS = GS<EXT>>,
+    NS<EXT>: NodeSegmentOps<Extension = EXT>,
+    ES<EXT>: EdgeSegmentOps<Extension = EXT>,
+    GS<EXT>: GraphPropSegmentOps<Extension = EXT>,
+{
+    pub nodes: WriteLockedNodePages<'a, storage::NS<EXT>>,
+    pub edges: WriteLockedEdgePages<'a, storage::ES<EXT>>,
+    pub graph_props: WriteLockedGraphPropPages<'a, storage::GS<EXT>>,
+    pub graph: &'a TemporalGraph<EXT>,
+}
+
+impl<'a, EXT> WriteLockedGraph<'a, EXT>
+where
+    EXT: PersistenceStrategy<NS = NS<EXT>, ES = ES<EXT>, GS = GS<EXT>>,
+    NS<EXT>: NodeSegmentOps<Extension = EXT>,
+    ES<EXT>: EdgeSegmentOps<Extension = EXT>,
+    GS<EXT>: GraphPropSegmentOps<Extension = EXT>,
+{
+    pub fn new(graph: &'a TemporalGraph<EXT>) -> Self {
+        WriteLockedGraph {
+            nodes: graph.storage.nodes().write_locked(),
+            edges: graph.storage.edges().write_locked(),
+            graph_props: graph.storage.graph_props().write_locked(),
+            graph,
+        }
+    }
+
+    pub fn graph(&self) -> &TemporalGraph<EXT> {
+        self.graph
+    }
+
+    pub fn resize_segments_to_vid(&mut self, vid: VID) {
+        let (segment_id, _) = self.graph.storage.nodes().resolve_pos(vid);
+        self.graph.storage().nodes().grow(segment_id + 1);
+        std::mem::take(&mut self.nodes);
+        self.nodes = self.graph.storage.nodes().write_locked();
+    }
+
+    pub fn resize_segments_to_eid(&mut self, eid: EID) {
+        let (segment_id, _) = self.graph.storage.edges().resolve_pos(eid);
+        self.graph.storage().edges().grow(segment_id + 1);
+        std::mem::take(&mut self.edges);
+        self.edges = self.graph.storage.edges().write_locked();
+    }
+
+    pub fn edge_stats(&self) -> &Arc<GraphStats> {
+        self.graph.storage().edges().stats()
+    }
+
+    pub fn node_stats(&self) -> &Arc<GraphStats> {
+        self.graph.storage().nodes().stats()
+    }
+}
diff --git a/db4-graph/src/replay.rs b/db4-graph/src/replay.rs
new file mode 100644
index 0000000000..fffe0dca6a
--- /dev/null
+++ b/db4-graph/src/replay.rs
@@ -0,0 +1,678 @@
+//! Implements WAL replay for a `WriteLockedGraph`.
+//! Allows for fast replay by making use of one-time lock acquisition for
+//! all the segments in the graph.
+
+use crate::WriteLockedGraph;
+use raphtory_api::core::{
+    entities::{
+        properties::{
+            meta::{Meta, STATIC_GRAPH_LAYER_ID},
+            prop::Prop,
+        },
+        LayerId, EID, GID, VID,
+    },
+    storage::timeindex::EventTime,
+};
+use storage::{
+    api::{edges::EdgeSegmentOps, graph_props::GraphPropSegmentOps, nodes::NodeSegmentOps},
+    error::StorageError,
+    persist::strategy::PersistenceStrategy,
+    resolver::GIDResolverOps,
+    wal::{GraphReplay, TransactionID, LSN},
+    ES, GS, NS,
+};
+
+impl<EXT> GraphReplay for WriteLockedGraph<'_, EXT>
+where
+    EXT: PersistenceStrategy<NS = NS<EXT>, ES = ES<EXT>, GS = GS<EXT>>,
+    NS<EXT>: NodeSegmentOps<Extension = EXT>,
+    ES<EXT>: EdgeSegmentOps<Extension = EXT>,
+    GS<EXT>: GraphPropSegmentOps<Extension = EXT>,
+{
+    fn replay_add_edge(
+        &mut self,
+        lsn: LSN,
+        _transaction_id: TransactionID,
+        t: EventTime,
+        src_name: Option<GID>,
+        src_id: VID,
+        dst_name: Option<GID>,
+        dst_id: VID,
+        eid: EID,
+        layer_name: Option<String>,
+        layer_id: LayerId,
+        props: Vec<(String, usize, Prop)>,
+    ) -> Result<(), StorageError> {
+        // Insert node ids into resolver.
+        if let Some(src_name) = src_name.as_ref() {
+            self.graph()
+                .logical_to_physical
+                .set(src_name.as_ref(), src_id)?;
+        }
+
+        if let Some(dst_name) = dst_name.as_ref() {
+            self.graph()
+                .logical_to_physical
+                .set(dst_name.as_ref(), dst_id)?;
+        }
+
+        // Insert layer id into the layer meta of both edge and node.
+        self.graph()
+            .edge_meta()
+            .layer_meta()
+            .set_id(layer_name.as_deref().unwrap_or("_default"), layer_id.0);
+        self.graph()
+            .node_meta()
+            .layer_meta()
+            .set_id(layer_name.as_deref().unwrap_or("_default"), layer_id.0);
+
+        // Grab src writer and add edge data.
+        let (src_segment_id, src_pos) = self.graph().storage().nodes().resolve_pos(src_id);
+        self.resize_segments_to_vid(src_id); // Create enough segments.
+
+        let segment = self
+            .graph()
+            .storage()
+            .nodes()
+            .get_or_create_segment(src_segment_id);
+
+        let immut_lsn = segment.immut_lsn();
+
+        // Replay this entry only if it doesn't exist in immut.
+        if immut_lsn < lsn {
+            let src_writer = self.nodes.get_mut(src_segment_id).ok_or_else(|| {
+                StorageError::GenericFailure(format!(
+                    "Node segment {src_segment_id} not found during replay_add_edge"
+                ))
+            })?;
+
+            let mut src_writer = src_writer.writer();
+
+            // Increment the node counter for this segment if this is a new node.
+            if !src_writer.has_node(src_pos, STATIC_GRAPH_LAYER_ID) {
+                src_writer.increment_seg_num_nodes();
+            }
+
+            if let Some(src_name) = src_name {
+                src_writer.store_node_id(src_pos, STATIC_GRAPH_LAYER_ID, src_name);
+            }
+
+            let is_new_edge_in_static = src_writer
+                .get_out_edge(src_pos, dst_id, STATIC_GRAPH_LAYER_ID)
+                .is_none();
+
+            let is_new_edge_in_layer = src_writer.get_out_edge(src_pos, dst_id, layer_id).is_none();
+
+            // Add the edge to the static graph if it doesn't already exist.
+            if is_new_edge_in_static {
+                src_writer.add_static_outbound_edge(src_pos, dst_id, eid);
+            }
+
+            // Add the edge to the layer if it doesn't already exist, else just record the timestamp.
+            if is_new_edge_in_layer {
+                src_writer.add_outbound_edge(Some(t), src_pos, dst_id, eid.with_layer(layer_id));
+            } else {
+                src_writer.update_timestamp(t, src_pos, eid.with_layer(layer_id));
+            }
+
+            src_writer.set_lsn(lsn);
+        }
+
+        // Grab dst writer and add edge data.
+        let (dst_segment_id, dst_pos) = self.graph().storage().nodes().resolve_pos(dst_id);
+        self.resize_segments_to_vid(dst_id);
+
+        let segment = self
+            .graph()
+            .storage()
+            .nodes()
+            .get_or_create_segment(dst_segment_id);
+
+        let immut_lsn = segment.immut_lsn();
+
+        // Replay this entry only if it doesn't exist in immut.
+        if immut_lsn < lsn {
+            let dst_writer = self.nodes.get_mut(dst_segment_id).ok_or_else(|| {
+                StorageError::GenericFailure(format!(
+                    "Node segment {dst_segment_id} not found during replay_add_edge"
+                ))
+            })?;
+
+            let mut dst_writer = dst_writer.writer();
+
+            // Increment the node counter for this segment if this is a new node.
+            if !dst_writer.has_node(dst_pos, STATIC_GRAPH_LAYER_ID) {
+                dst_writer.increment_seg_num_nodes();
+            }
+
+            if let Some(dst_name) = dst_name {
+                dst_writer.store_node_id(dst_pos, STATIC_GRAPH_LAYER_ID, dst_name);
+            }
+
+            let is_new_edge_in_static = dst_writer
+                .get_inb_edge(dst_pos, src_id, STATIC_GRAPH_LAYER_ID)
+                .is_none();
+
+            let is_new_edge_in_layer = dst_writer.get_inb_edge(dst_pos, src_id, layer_id).is_none();
+
+            if is_new_edge_in_static {
+                dst_writer.add_static_inbound_edge(dst_pos, src_id, eid);
+            }
+
+            if is_new_edge_in_layer {
+                dst_writer.add_inbound_edge(Some(t), dst_pos, src_id, eid.with_layer(layer_id));
+            } else {
+                dst_writer.update_timestamp(t, dst_pos, eid.with_layer(layer_id));
+            }
+
+            dst_writer.set_lsn(lsn);
+        }
+
+        // Grab edge writer and add temporal props.
+        let (edge_segment_id, edge_pos) = self.graph().storage().edges().resolve_pos(eid);
+        self.resize_segments_to_eid(eid);
+
+        let segment = self
+            .graph()
+            .storage()
+            .edges()
+            .get_or_create_segment(edge_segment_id);
+
+        let immut_lsn = segment.immut_lsn();
+
+        // Replay this entry only if it doesn't exist in immut.
+        if immut_lsn < lsn {
+            let edge_meta = self.graph().edge_meta();
+
+            // Insert prop ids into edge meta.
+            unify_types(edge_meta, &props, true)?;
+
+            let edge_writer = self.edges.get_mut(edge_segment_id).ok_or_else(|| {
+                StorageError::GenericFailure(format!(
+                    "Edge segment {edge_segment_id} not found during replay_add_edge"
+                ))
+            })?;
+
+            let mut edge_writer = edge_writer.writer();
+
+            let is_new_edge_in_static = edge_writer
+                .get_edge(STATIC_GRAPH_LAYER_ID, edge_pos)
+                .is_none();
+
+            // Add edge into the static graph if it doesn't already exist.
+            if is_new_edge_in_static {
+                let already_counted = false;
+                edge_writer.add_static_edge(Some(edge_pos), src_id, dst_id, already_counted);
+            }
+
+            // Add edge into the specified layer with timestamp and props.
+            edge_writer.add_edge(
+                t,
+                edge_pos,
+                src_id,
+                dst_id,
+                props
+                    .into_iter()
+                    .map(|(_, prop_id, prop_value)| (prop_id, prop_value)),
+                layer_id,
+            );
+
+            edge_writer.set_lsn(lsn);
+        }
+
+        Ok(())
+    }
+
+    fn replay_add_edge_metadata(
+        &mut self,
+        lsn: LSN,
+        _transaction_id: TransactionID,
+        eid: EID,
+        layer_id: LayerId,
+        props: Vec<(String, usize, Prop)>,
+    ) -> Result<(), StorageError> {
+        let (edge_segment_id, edge_pos) = self.graph().storage().edges().resolve_pos(eid);
+        self.resize_segments_to_eid(eid);
+
+        let segment = self
+            .graph()
+            .storage()
+            .edges()
+            .get_or_create_segment(edge_segment_id);
+
+        let immut_lsn = segment.immut_lsn();
+
+        if immut_lsn < lsn {
+            let edge_meta = self.graph().edge_meta();
+
+            unify_types(edge_meta, &props, false)?;
+
+            let edge_writer = self.edges.get_mut(edge_segment_id).ok_or_else(|| {
+                StorageError::GenericFailure(format!(
+                    "Edge segment {edge_segment_id} not found during replay_add_edge_metadata"
+                ))
+            })?;
+
+            let mut edge_writer = edge_writer.writer();
+
+            let (src, dst) = edge_writer.get_edge(layer_id, edge_pos).ok_or_else(|| {
+                StorageError::GenericFailure(format!(
+                    "Edge {eid:?} not found in layer {layer_id} during replay_add_edge_metadata"
+                ))
+            })?;
+
+            let props = props.into_iter().map(|(_, id, p)| (id, p));
+
+            // No need to check metadata since the operation was logged after validation.
+            edge_writer.update_c_props(edge_pos, src, dst, layer_id, props);
+            edge_writer.set_lsn(lsn);
+        }
+
+        Ok(())
+    }
+
+    fn replay_delete_edge(
+        &mut self,
+        lsn: LSN,
+        _transaction_id: TransactionID,
+        t: EventTime,
+        src_name: Option<GID>,
+        src_id: VID,
+        dst_name: Option<GID>,
+        dst_id: VID,
+        eid: EID,
+        layer_name: Option<String>,
+        layer_id: LayerId,
+    ) -> Result<(), StorageError> {
+        // Insert node ids into resolver.
+        if let Some(src_name) = src_name.as_ref() {
+            self.graph()
+                .logical_to_physical
+                .set(src_name.as_ref(), src_id)?;
+        }
+
+        if let Some(dst_name) = dst_name.as_ref() {
+            self.graph()
+                .logical_to_physical
+                .set(dst_name.as_ref(), dst_id)?;
+        }
+
+        // Insert layer id into the layer meta of both edge and node.
+        self.graph()
+            .edge_meta()
+            .layer_meta()
+            .set_id(layer_name.as_deref().unwrap_or("_default"), layer_id.0);
+        self.graph()
+            .node_meta()
+            .layer_meta()
+            .set_id(layer_name.as_deref().unwrap_or("_default"), layer_id.0);
+
+        // Grab src writer and record deletion time.
+        let (src_segment_id, src_pos) = self.graph().storage().nodes().resolve_pos(src_id);
+        self.resize_segments_to_vid(src_id);
+
+        let segment = self
+            .graph()
+            .storage()
+            .nodes()
+            .get_or_create_segment(src_segment_id);
+
+        let immut_lsn = segment.immut_lsn();
+
+        if immut_lsn < lsn {
+            let src_writer = self.nodes.get_mut(src_segment_id).ok_or_else(|| {
+                StorageError::GenericFailure(format!(
+                    "Node segment {src_segment_id} not found during replay_delete_edge"
+                ))
+            })?;
+
+            let mut src_writer = src_writer.writer();
+
+            // Increment the node counter for this segment if this is a new node.
+            if !src_writer.has_node(src_pos, STATIC_GRAPH_LAYER_ID) {
+                src_writer.increment_seg_num_nodes();
+            }
+
+            if let Some(src_name) = src_name {
+                src_writer.store_node_id(src_pos, STATIC_GRAPH_LAYER_ID, src_name);
+            }
+
+            let is_new_edge_in_static = src_writer
+                .get_out_edge(src_pos, dst_id, STATIC_GRAPH_LAYER_ID)
+                .is_none();
+            let is_new_edge_in_layer = src_writer.get_out_edge(src_pos, dst_id, layer_id).is_none();
+
+            // Add the edge to the static graph if it doesn't already exist.
+            if is_new_edge_in_static {
+                src_writer.add_static_outbound_edge(src_pos, dst_id, eid);
+            }
+
+            // Add the edge to the layer if it doesn't already exist.
+            if is_new_edge_in_layer {
+                src_writer.add_outbound_edge(Some(t), src_pos, dst_id, eid.with_layer(layer_id));
+            }
+
+            src_writer.update_deletion_time(t, src_pos, eid.with_layer(layer_id));
+            src_writer.set_lsn(lsn);
+        }
+
+        // Grab dst writer and record deletion time.
+        let (dst_segment_id, dst_pos) = self.graph().storage().nodes().resolve_pos(dst_id);
+        self.resize_segments_to_vid(dst_id);
+
+        let segment = self
+            .graph()
+            .storage()
+            .nodes()
+            .get_or_create_segment(dst_segment_id);
+
+        let immut_lsn = segment.immut_lsn();
+
+        if immut_lsn < lsn {
+            let dst_writer = self.nodes.get_mut(dst_segment_id).ok_or_else(|| {
+                StorageError::GenericFailure(format!(
+                    "Node segment {dst_segment_id} not found during replay_delete_edge"
+                ))
+            })?;
+
+            let mut dst_writer = dst_writer.writer();
+
+            // Increment the node counter for this segment if this is a new node.
+            if !dst_writer.has_node(dst_pos, STATIC_GRAPH_LAYER_ID) {
+                dst_writer.increment_seg_num_nodes();
+            }
+
+            if let Some(dst_name) = dst_name {
+                dst_writer.store_node_id(dst_pos, STATIC_GRAPH_LAYER_ID, dst_name);
+            }
+
+            let is_new_edge_in_static = dst_writer
+                .get_inb_edge(dst_pos, src_id, STATIC_GRAPH_LAYER_ID)
+                .is_none();
+
+            let is_new_edge_in_layer = dst_writer.get_inb_edge(dst_pos, src_id, layer_id).is_none();
+
+            // Add the edge to the static graph if it doesn't already exist.
+            if is_new_edge_in_static {
+                dst_writer.add_static_inbound_edge(dst_pos, src_id, eid);
+            }
+
+            // Add the edge to the layer if it doesn't already exist.
+            if is_new_edge_in_layer {
+                dst_writer.add_inbound_edge(Some(t), dst_pos, src_id, eid.with_layer(layer_id));
+            }
+
+            // Always update the deletion time on the edge.
+            dst_writer.update_deletion_time(t, dst_pos, eid.with_layer(layer_id));
+
+            dst_writer.set_lsn(lsn);
+        }
+
+        // Grab edge writer and delete the edge at (t, layer_id).
+        let (edge_segment_id, edge_pos) = self.graph().storage().edges().resolve_pos(eid);
+        self.resize_segments_to_eid(eid);
+
+        let segment = self
+            .graph()
+            .storage()
+            .edges()
+            .get_or_create_segment(edge_segment_id);
+
+        let immut_lsn = segment.immut_lsn();
+
+        if immut_lsn < lsn {
+            let edge_writer = self.edges.get_mut(edge_segment_id).ok_or_else(|| {
+                StorageError::GenericFailure(format!(
+                    "Edge segment {edge_segment_id} not found during replay_delete_edge"
+                ))
+            })?;
+
+            let mut edge_writer = edge_writer.writer();
+
+            let is_new_edge_in_static = edge_writer
+                .get_edge(STATIC_GRAPH_LAYER_ID, edge_pos)
+                .is_none();
+
+            // Add the edge to the static graph if it doesn't already exist.
+            if is_new_edge_in_static {
+                let already_counted = false;
+                edge_writer.add_static_edge(Some(edge_pos), src_id, dst_id, already_counted);
+            }
+
+            // Delete the edge from the layer at the specified timestamp.
+            edge_writer.delete_edge(t, edge_pos, src_id, dst_id, layer_id);
+
+            edge_writer.set_lsn(lsn);
+        }
+
+        Ok(())
+    }
+
+    fn replay_add_node(
+        &mut self,
+        lsn: LSN,
+        _transaction_id: TransactionID,
+        t: EventTime,
+        node_name: Option<GID>,
+        node_id: VID,
+        node_type_and_id: Option<(String, usize)>,
+        props: Vec<(String, usize, Prop)>,
+    ) -> Result<(), StorageError> {
+        // Insert node id into resolver.
+        if let Some(ref name) = node_name {
+            self.graph()
+                .logical_to_physical
+                .set(name.as_ref(), node_id)?;
+        }
+
+        // Resolve segment and check LSN.
+        let (segment_id, pos) = self.graph().storage().nodes().resolve_pos(node_id);
+        self.resize_segments_to_vid(node_id);
+
+        let segment = self
+            .graph()
+            .storage()
+            .nodes()
+            .get_or_create_segment(segment_id);
+
+        let immut_lsn = segment.immut_lsn();
+
+        // Replay this entry only if it doesn't exist in immut.
+        if immut_lsn < lsn {
+            let node_meta = self.graph().node_meta();
+
+            unify_types(node_meta, &props, true)?;
+
+            // Set node type metadata early to prevent issues with borrowing node_writer.
+            if let Some((ref node_type, node_type_id)) = node_type_and_id {
+                node_meta
+                    .node_type_meta()
+                    .set_id(node_type.as_str(), node_type_id);
+            }
+
+            let node_writer = self.nodes.get_mut(segment_id).ok_or_else(|| {
+                StorageError::GenericFailure(format!(
+                    "Node segment {segment_id} not found during replay_add_node"
+                ))
+            })?;
+
+            let mut node_writer = node_writer.writer();
+
+            if !node_writer.has_node(pos, STATIC_GRAPH_LAYER_ID) {
+                node_writer.increment_seg_num_nodes();
+            }
+
+            if let Some(name) = node_name {
+                node_writer.store_node_id(pos, STATIC_GRAPH_LAYER_ID, name);
+            }
+
+            if let Some((_, node_type_id)) = node_type_and_id {
+                node_writer.store_node_type(pos, STATIC_GRAPH_LAYER_ID, node_type_id);
+            }
+
+            // Add the node with its timestamp and props.
+            node_writer.add_props(
+                t,
+                pos,
+                STATIC_GRAPH_LAYER_ID,
+                props
+                    .into_iter()
+                    .map(|(_, prop_id, prop_value)| (prop_id, prop_value)),
+            );
+
+            node_writer.set_lsn(lsn);
+        }
+
+        Ok(())
+    }
+
+    fn replay_add_node_metadata(
+        &mut self,
+        lsn: LSN,
+        _transaction_id: TransactionID,
+        vid: VID,
+        props: Vec<(String, usize, Prop)>,
+    ) -> Result<(), StorageError> {
+        let (segment_id, pos) = self.graph().storage().nodes().resolve_pos(vid);
+        self.resize_segments_to_vid(vid);
+
+        let segment = self
+            .graph()
+            .storage()
+            .nodes()
+            .get_or_create_segment(segment_id);
+
+        let immut_lsn = segment.immut_lsn();
+
+        if immut_lsn < lsn {
+            let node_meta = self.graph().node_meta();
+
+            unify_types(&node_meta, &props, false)?;
+
+            let node_writer = self.nodes.get_mut(segment_id).ok_or_else(|| {
+                StorageError::GenericFailure(format!(
+                    "Node segment {segment_id} not found during replay_add_node_metadata"
+                ))
+            })?;
+
+            let mut node_writer = node_writer.writer();
+            let props = props.into_iter().map(|(_, id, p)| (id, p));
+
+            // No need to check metadata since the operation was logged after validation.
+            node_writer.update_c_props(pos, STATIC_GRAPH_LAYER_ID, props);
+            node_writer.set_lsn(lsn);
+        }
+
+        Ok(())
+    }
+
+    fn replay_set_node_type(
+        &mut self,
+        lsn: LSN,
+        _transaction_id: TransactionID,
+        vid: VID,
+        node_type: String,
+        node_type_id: usize,
+    ) -> Result<(), StorageError> {
+        let (segment_id, pos) = self.graph().storage().nodes().resolve_pos(vid);
+        self.resize_segments_to_vid(vid);
+
+        let segment = self
+            .graph()
+            .storage()
+            .nodes()
+            .get_or_create_segment(segment_id);
+
+        let immut_lsn = segment.immut_lsn();
+
+        if immut_lsn < lsn {
+            let node_meta = self.graph().node_meta();
+
+            node_meta
+                .node_type_meta()
+                .set_id(node_type.as_str(), node_type_id);
+
+            let node_writer = self.nodes.get_mut(segment_id).ok_or_else(|| {
+                StorageError::GenericFailure(format!(
+                    "Node segment {segment_id} not found during replay_set_node_type"
+                ))
+            })?;
+            let mut node_writer = node_writer.writer();
+
+            node_writer.store_node_type(pos, STATIC_GRAPH_LAYER_ID, node_type_id);
+            node_writer.set_lsn(lsn);
+        }
+
+        Ok(())
+    }
+
+    fn replay_add_graph_props(
+        &mut self,
+        lsn: LSN,
+        _transaction_id: TransactionID,
+        t: EventTime,
+        props: Vec<(String, usize, Prop)>,
+    ) -> Result<(), StorageError> {
+        let segment = self.graph().storage().graph_props().segment();
+        let immut_lsn = segment.immut_lsn();
+
+        if immut_lsn < lsn {
+            let graph_props_meta = self.graph().graph_props_meta();
+
+            unify_types(graph_props_meta, &props, true)?;
+
+            let writer = self.graph_props.writer();
+            let props = props.into_iter().map(|(_, id, p)| (id, p));
+
+            writer.add_properties(t, props);
+            writer.set_lsn(lsn);
+        }
+
+        Ok(())
+    }
+
+    fn replay_add_graph_metadata(
+        &mut self,
+        lsn: LSN,
+        _transaction_id: TransactionID,
+        props: Vec<(String, usize, Prop)>,
+    ) -> Result<(), StorageError> {
+        let segment = self.graph().storage().graph_props().segment();
+        let immut_lsn = segment.immut_lsn();
+
+        if immut_lsn < lsn {
+            let graph_props_meta = self.graph().graph_props_meta();
+
+            unify_types(graph_props_meta, &props, false)?;
+
+            let writer = self.graph_props.writer();
+            let props = props.into_iter().map(|(_, id, p)| (id, p));
+
+            writer.update_metadata(props);
+            writer.set_lsn(lsn);
+        }
+
+        Ok(())
+    }
+}
+
+fn unify_types(
+    meta: &Meta,
+    props: &[(String, usize, Prop)],
+    temporal: bool,
+) -> Result<(), StorageError> {
+    let prop_mapper = if !temporal {
+        meta.metadata_mapper()
+    } else {
+        meta.temporal_prop_mapper()
+    };
+    let mut write_locked_mapper = prop_mapper.write_locked();
+    for (prop_name, prop_id, prop_value) in props {
+        write_locked_mapper.set_or_unify_id_and_dtype(
+            prop_name.as_ref(),
+            *prop_id,
+            prop_value.dtype(),
+        )?;
+    }
+    Ok(())
+}
diff --git a/db4-storage/Cargo.toml b/db4-storage/Cargo.toml
new file mode 100644
index 0000000000..cf0d0b68c0
--- /dev/null
+++ b/db4-storage/Cargo.toml
@@ -0,0 +1,49 @@
+[package]
+name = "db4-storage"
+version.workspace = true
+documentation.workspace = true
+repository.workspace = true
+readme.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+authors.workspace = true
+rust-version.workspace = true
+edition = "2024"
+
+[dependencies]
+raphtory-api.workspace = true
+raphtory-api-macros.workspace = true
+raphtory-core = { workspace = true }
+bigdecimal.workspace = true
+either.workspace = true
+parking_lot.workspace = true
+serde.workspace = true
+boxcar.workspace = true
+serde_json.workspace = true
+arrow-array.workspace = true
+arrow-schema.workspace = true
+parquet.workspace = true
+rayon.workspace = true
+itertools.workspace = true
+thiserror.workspace = true
+tinyvec.workspace = true
+proptest = { workspace = true, optional = true }
+tempfile = { workspace = true }
+iter-enum = { workspace = true, features = ["rayon"] }
+chrono = { workspace = true, optional = true }
+clap.workspace = true
+tracing.workspace = true
+dashmap.workspace = true
+lock_api.workspace = true
+once_cell.workspace = true
+
+[dev-dependencies]
+proptest.workspace = true
+tempfile.workspace = true
+chrono.workspace = true
+rayon.workspace = true
+test-log.workspace = true
+
+[features]
+test-utils = ["dep:proptest", "dep:chrono"]
+default = ["test-utils"]
diff --git a/db4-storage/build.rs b/db4-storage/build.rs
new file mode 100644
index 0000000000..7acbc3f99d
--- /dev/null
+++ b/db4-storage/build.rs
@@ -0,0 +1,9 @@
+use std::io::Result;
+
+fn main() -> Result<()> {
+    println!("cargo::rustc-check-cfg=cfg(has_debug_symbols)");
+    if let Ok("true" | "1" | "2") = std::env::var("DEBUG").as_deref() {
+        println!("cargo::rustc-cfg=has_debug_symbols");
+    }
+    Ok(())
+}
diff --git a/db4-storage/src/api/edges.rs b/db4-storage/src/api/edges.rs
new file mode 100644
index 0000000000..74082bc59b
--- /dev/null
+++ b/db4-storage/src/api/edges.rs
@@ -0,0 +1,180 @@
+use crate::{
+    LocalPOS, error::StorageError, persist::strategy::PersistenceStrategy,
+    segments::edge::segment::MemEdgeSegment, wal::LSN,
+};
+use parking_lot::{RwLockReadGuard, RwLockWriteGuard, lock_api::ArcRwLockReadGuard};
+use raphtory_api::core::entities::{
+    LayerId,
+    properties::{meta::Meta, prop::Prop, tprop::TPropOps},
+};
+use raphtory_core::{
+    entities::{EID, LayerIds, VID},
+    storage::timeindex::{EventTime, TimeIndexOps},
+};
+use rayon::iter::ParallelIterator;
+use std::{
+    ops::{Deref, DerefMut},
+    path::{Path, PathBuf},
+    sync::{Arc, atomic::AtomicU32},
+};
+
+pub trait EdgeSegmentOps: Send + Sync + std::fmt::Debug + 'static {
+    type Extension: PersistenceStrategy<ES = Self>;
+
+    type Entry<'a>: EdgeEntryOps<'a>
+    where
+        Self: 'a;
+
+    type ArcLockedSegment: LockedESegment;
+
+    fn extension(&self) -> &Self::Extension;
+
+    fn latest(&self) -> Option<EventTime>;
+    fn earliest(&self) -> Option<EventTime>;
+
+    fn t_len(&self) -> usize;
+    fn num_layers(&self) -> usize;
+    // Persistent layer count, not used for up-to-date counts
+    fn layer_count(&self, layer_id: LayerId) -> u32;
+
+    fn load(
+        page_id: usize,
+        max_page_len: u32,
+        meta: Arc<Meta>,
+        path: impl AsRef<Path>,
+        ext: Self::Extension,
+    ) -> Result<Self, StorageError>
+    where
+        Self: Sized;
+
+    fn new(page_id: usize, meta: Arc<Meta>, path: Option<PathBuf>, ext: Self::Extension) -> Self;
+
+    fn segment_id(&self) -> usize;
+
+    fn edges_counter(&self) -> &AtomicU32;
+
+    fn num_edges(&self) -> u32 {
+        self.edges_counter()
+            .load(std::sync::atomic::Ordering::Relaxed)
+    }
+
+    fn head(&self) -> RwLockReadGuard<'_, MemEdgeSegment>;
+
+    fn head_arc(&self) -> ArcRwLockReadGuard<parking_lot::RawRwLock, MemEdgeSegment>;
+
+    fn head_mut(&self) -> RwLockWriteGuard<'_, MemEdgeSegment>;
+
+    fn try_head_mut(&self) -> Option<RwLockWriteGuard<'_, MemEdgeSegment>>;
+
+    fn set_dirty(&self, dirty: bool);
+
+    fn is_dirty(&self) -> bool;
+
+    /// notify that an edge was added (might need to write to disk)
+    fn notify_write(
+        &self,
+        head_lock: impl DerefMut<Target = MemEdgeSegment>,
+    ) -> Result<(), StorageError>;
+
+    fn increment_num_edges(&self) -> u32 {
+        self.edges_counter()
+            .fetch_add(1, std::sync::atomic::Ordering::Relaxed)
+    }
+
+    fn has_edge(
+        &self,
+        edge_pos: LocalPOS,
+        layer_id: LayerId,
+        locked_head: impl Deref<Target = MemEdgeSegment>,
+    ) -> bool;
+
+    fn immut_has_edge(&self, edge_pos: LocalPOS, layer_id: LayerId) -> bool;
+
+    fn get_edge(
+        &self,
+        edge_pos: LocalPOS,
+        layer_id: LayerId,
+        locked_head: impl Deref<Target = MemEdgeSegment>,
+    ) -> Option<(VID, VID)>;
+
+    fn entry<'a>(&'a self, edge_pos: LocalPOS) -> Self::Entry<'a>;
+
+    fn layer_entry<'a>(
+        &'a self,
+        edge_pos: LocalPOS,
+        layer_id: LayerId,
+        locked_head: Option<parking_lot::RwLockReadGuard<'a, MemEdgeSegment>>,
+    ) -> Option<Self::Entry<'a>>;
+
+    fn locked(self: &Arc<Self>) -> Self::ArcLockedSegment;
+
+    fn vacuum(
+        &self,
+        locked_head: impl DerefMut<Target = MemEdgeSegment>,
+    ) -> Result<(), StorageError>;
+
+    /// Returns the latest lsn for the immutable part of this segment.
+    fn immut_lsn(&self) -> LSN;
+
+    fn flush(&self) -> Result<(), StorageError>;
+}
+
+pub trait LockedESegment: Send + Sync + std::fmt::Debug {
+    type EntryRef<'a>: EdgeRefOps<'a>
+    where
+        Self: 'a;
+
+    fn entry_ref<'a>(&'a self, edge_pos: impl Into<LocalPOS>) -> Self::EntryRef<'a>
+    where
+        Self: 'a;
+
+    fn edge_iter<'a, 'b: 'a>(
+        &'a self,
+        layer_ids: &'b LayerIds,
+    ) -> impl Iterator<Item = Self::EntryRef<'a>> + Send + Sync + 'a;
+
+    fn edge_par_iter<'a, 'b: 'a>(
+        &'a self,
+        layer_ids: &'b LayerIds,
+    ) -> impl ParallelIterator<Item = Self::EntryRef<'a>> + Sync + 'a;
+
+    fn num_edges(&self) -> u32;
+}
+
+pub trait EdgeEntryOps<'a>: Send + Sync {
+    type Ref<'b>: EdgeRefOps<'b>
+    where
+        'a: 'b,
+        Self: 'b;
+
+    fn as_ref<'b>(&'b self) -> Self::Ref<'b>
+    where
+        'a: 'b;
+}
+
+pub trait EdgeRefOps<'a>: Copy + Clone + Send + Sync {
+    type Additions: TimeIndexOps<'a, IndexType = EventTime>;
+    type Deletions: TimeIndexOps<'a, IndexType = EventTime>;
+    type TProps: TPropOps<'a>;
+
+    fn edge(self, layer_id: LayerId) -> Option<(VID, VID)>;
+
+    fn has_layer_inner(self, layer_id: LayerId) -> bool {
+        self.edge(layer_id).is_some()
+    }
+
+    fn internal_num_layers(self) -> usize;
+
+    fn layer_additions(self, layer_id: LayerId) -> Self::Additions;
+    fn layer_deletions(self, layer_id: LayerId) -> Self::Deletions;
+
+    fn c_prop(self, layer_id: LayerId, prop_id: usize) -> Option<Prop>;
+
+    fn layer_t_prop(self, layer_id: LayerId, prop_id: usize) -> Self::TProps;
+
+    fn src(&self) -> Option<VID>;
+
+    fn dst(&self) -> Option<VID>;
+
+    fn edge_id(&self) -> EID;
+}
diff --git a/db4-storage/src/api/graph_props.rs b/db4-storage/src/api/graph_props.rs
new file mode 100644
index 0000000000..824510a4c6
--- /dev/null
+++ b/db4-storage/src/api/graph_props.rs
@@ -0,0 +1,65 @@
+use crate::{error::StorageError, segments::graph_prop::segment::MemGraphPropSegment, wal::LSN};
+use parking_lot::{RwLockReadGuard, RwLockWriteGuard};
+use raphtory_api::core::entities::properties::{meta::Meta, prop::Prop, tprop::TPropOps};
+use std::{fmt::Debug, path::Path, sync::Arc};
+
+pub trait GraphPropSegmentOps: Send + Sync + Debug + 'static
+where
+    Self: Sized,
+{
+    type Extension;
+
+    type Entry<'a>: GraphPropEntryOps<'a>;
+
+    fn new(meta: Arc<Meta>, path: Option<&Path>, ext: Self::Extension) -> Self;
+
+    fn load(
+        meta: Arc<Meta>,
+        path: impl AsRef<Path>,
+        ext: Self::Extension,
+    ) -> Result<Self, StorageError>;
+
+    fn head(&self) -> RwLockReadGuard<'_, MemGraphPropSegment>;
+
+    fn head_mut(&self) -> RwLockWriteGuard<'_, MemGraphPropSegment>;
+
+    fn entry(&self) -> Self::Entry<'_>;
+
+    fn increment_est_size(&self, size: usize);
+
+    fn est_size(&self) -> usize;
+
+    fn set_dirty(&self, dirty: bool);
+
+    /// Returns the latest lsn for the immutable part of this segment.
+    fn immut_lsn(&self) -> LSN;
+
+    fn notify_write(
+        &self,
+        mem_segment: &mut RwLockWriteGuard<'_, MemGraphPropSegment>,
+    ) -> Result<(), StorageError>;
+
+    fn flush(&self) -> Result<(), StorageError>;
+}
+
+/// Trait for returning a guard-free, copyable reference to graph properties
+/// and metadata.
+pub trait GraphPropEntryOps<'a>: Send + Sync + 'a {
+    type Ref<'b>: GraphPropRefOps<'b>
+    where
+        'a: 'b,
+        Self: 'b;
+
+    fn as_ref<'b>(&'b self) -> Self::Ref<'b>
+    where
+        'a: 'b;
+}
+
+/// Methods for reading graph properties and metadata from a reference on storage.
+pub trait GraphPropRefOps<'a>: Copy + Clone + Send + Sync + 'a {
+    type TProps: TPropOps<'a>;
+
+    fn get_temporal_prop(self, prop_id: usize) -> Self::TProps;
+
+    fn get_metadata(self, prop_id: usize) -> Option<Prop>;
+}
diff --git a/db4-storage/src/api/mod.rs b/db4-storage/src/api/mod.rs
new file mode 100644
index 0000000000..de88345004
--- /dev/null
+++ b/db4-storage/src/api/mod.rs
@@ -0,0 +1,3 @@
+pub mod edges;
+pub mod graph_props;
+pub mod nodes;
diff --git a/db4-storage/src/api/nodes.rs b/db4-storage/src/api/nodes.rs
new file mode 100644
index 0000000000..d59e7447ec
--- /dev/null
+++ b/db4-storage/src/api/nodes.rs
@@ -0,0 +1,390 @@
+use itertools::Itertools;
+use parking_lot::{RwLockReadGuard, RwLockWriteGuard, lock_api::ArcRwLockReadGuard};
+use raphtory_api::{
+    core::{
+        Direction,
+        entities::properties::{
+            meta::{Meta, NODE_ID_IDX, NODE_TYPE_IDX},
+            prop::{Prop, PropUnwrap},
+            tprop::TPropOps,
+        },
+    },
+    iter::IntoDynBoxed,
+};
+use raphtory_api_macros::box_on_debug_lifetime;
+use raphtory_core::{
+    entities::{EID, GidRef, LayerIds, VID, edges::edge_ref::EdgeRef},
+    storage::timeindex::{EventTime, TimeIndexOps},
+    utils::iter::GenLockedIter,
+};
+use std::{
+    borrow::Cow,
+    fmt::Debug,
+    ops::{Deref, DerefMut, Range},
+    path::{Path, PathBuf},
+    sync::{
+        Arc,
+        atomic::{AtomicU32, Ordering},
+    },
+};
+
+use crate::{
+    LocalPOS,
+    error::StorageError,
+    gen_ts::LayerIter,
+    pages::node_store::increment_and_clamp,
+    segments::node::segment::MemNodeSegment,
+    utils::{Iter2, Iter3, Iter4},
+    wal::LSN,
+};
+use raphtory_api::core::entities::{LayerId, properties::meta::STATIC_GRAPH_LAYER_ID};
+use rayon::prelude::*;
+
+pub trait NodeSegmentOps: Send + Sync + Debug + 'static {
+    type Extension;
+
+    type Entry<'a>: NodeEntryOps<'a>
+    where
+        Self: 'a;
+
+    type ArcLockedSegment: LockedNSSegment;
+
+    fn latest(&self) -> Option<EventTime>;
+
+    fn earliest(&self) -> Option<EventTime>;
+
+    fn t_len(&self) -> usize;
+
+    fn load(
+        page_id: usize,
+        node_meta: Arc<Meta>,
+        edge_meta: Arc<Meta>,
+        path: impl AsRef<Path>,
+        ext: Self::Extension,
+    ) -> Result<Self, StorageError>
+    where
+        Self: Sized;
+
+    fn new(
+        page_id: usize,
+        node_meta: Arc<Meta>,
+        edge_meta: Arc<Meta>,
+        path: Option<PathBuf>,
+        ext: Self::Extension,
+    ) -> Self;
+
+    fn segment_id(&self) -> usize;
+
+    fn head_arc(&self) -> ArcRwLockReadGuard<parking_lot::RawRwLock, MemNodeSegment>;
+
+    fn head(&self) -> RwLockReadGuard<'_, MemNodeSegment>;
+
+    fn head_mut(&self) -> RwLockWriteGuard<'_, MemNodeSegment>;
+
+    fn try_head_mut(&self) -> Option<RwLockWriteGuard<'_, MemNodeSegment>>;
+
+    fn notify_write(
+        &self,
+        head_lock: impl DerefMut<Target = MemNodeSegment>,
+    ) -> Result<(), StorageError>;
+
+    fn set_dirty(&self, dirty: bool);
+
+    fn has_node(&self, pos: LocalPOS, layer_id: LayerId) -> bool;
+
+    fn get_out_edge(
+        &self,
+        pos: LocalPOS,
+        dst: impl Into<VID>,
+        layer_id: LayerId,
+        locked_head: impl Deref<Target = MemNodeSegment>,
+    ) -> Option<EID>;
+
+    fn get_inb_edge(
+        &self,
+        pos: LocalPOS,
+        src: impl Into<VID>,
+        layer_id: LayerId,
+        locked_head: impl Deref<Target = MemNodeSegment>,
+    ) -> Option<EID>;
+
+    fn entry(&self, pos: impl Into<LocalPOS>) -> Self::Entry<'_>;
+
+    fn locked(&self) -> Self::ArcLockedSegment;
+
+    fn flush(&self) -> Result<(), StorageError>;
+
+    fn is_dirty(&self) -> bool;
+
+    fn vacuum(
+        &self,
+        locked_head: impl DerefMut<Target = MemNodeSegment>,
+    ) -> Result<(), StorageError>;
+
+    /// Returns the latest lsn for the immutable part of this segment.
+    fn immut_lsn(&self) -> LSN;
+
+    fn nodes_counter(&self) -> &AtomicU32;
+
+    fn increment_num_nodes(&self, max_page_len: u32) {
+        increment_and_clamp(self.nodes_counter(), 1, max_page_len);
+    }
+
+    fn num_nodes(&self) -> u32 {
+        self.nodes_counter().load(Ordering::Relaxed)
+    }
+
+    fn num_layers(&self) -> usize;
+
+    fn layer_count(&self, layer_id: LayerId) -> u32;
+}
+
+pub trait LockedNSSegment: Debug + Send + Sync {
+    type EntryRef<'a>: NodeRefOps<'a>
+    where
+        Self: 'a;
+
+    fn num_nodes(&self) -> u32;
+
+    fn entry_ref<'a>(&'a self, pos: impl Into<LocalPOS>) -> Self::EntryRef<'a>;
+
+    fn iter_entries<'a>(&'a self) -> impl Iterator<Item = Self::EntryRef<'a>> + Send + Sync + 'a {
+        let num_nodes = self.num_nodes();
+        (0..num_nodes).map(move |vid| self.entry_ref(LocalPOS(vid)))
+    }
+
+    fn par_iter_entries<'a>(
+        &'a self,
+    ) -> impl ParallelIterator<Item = Self::EntryRef<'a>> + Sync + 'a {
+        let num_nodes = self.num_nodes();
+        (0..num_nodes)
+            .into_par_iter()
+            .map(move |vid| self.entry_ref(LocalPOS(vid)))
+    }
+}
+
+pub trait NodeEntryOps<'a>: Send + Sync + 'a {
+    type Ref<'b>: NodeRefOps<'b>
+    where
+        'a: 'b,
+        Self: 'b;
+
+    fn as_ref<'b>(&'b self) -> Self::Ref<'b>
+    where
+        'a: 'b;
+
+    fn into_edges<'b: 'a>(
+        self,
+        layers: &'b LayerIds,
+        dir: Direction,
+    ) -> impl Iterator<Item = EdgeRef> + Send + Sync + 'a
+    where
+        Self: Sized,
+    {
+        GenLockedIter::from((self, layers), |(e, layers)| {
+            e.as_ref().edges_iter(layers, dir).into_dyn_boxed()
+        })
+    }
+}
+
+pub trait NodeRefOps<'a>: Copy + Clone + Send + Sync + 'a {
+    type Additions: TimeIndexOps<'a, IndexType = EventTime>;
+    type EdgeAdditions: TimeIndexOps<'a, IndexType = EventTime>;
+    type TProps: TPropOps<'a>;
+
+    fn out_edges(self, layer_id: LayerId) -> impl Iterator<Item = (VID, EID)> + Send + Sync + 'a;
+
+    fn inb_edges(self, layer_id: LayerId) -> impl Iterator<Item = (VID, EID)> + Send + Sync + 'a;
+
+    fn out_edges_sorted(
+        self,
+        layer_id: LayerId,
+    ) -> impl Iterator<Item = (VID, EID)> + Send + Sync + 'a;
+
+    fn inb_edges_sorted(
+        self,
+        layer_id: LayerId,
+    ) -> impl Iterator<Item = (VID, EID)> + Send + Sync + 'a;
+
+    fn vid(&self) -> VID;
+
+    #[box_on_debug_lifetime]
+    fn edges_dir(
+        self,
+        layer_id: LayerId,
+        dir: Direction,
+    ) -> impl Iterator<Item = EdgeRef> + Send + Sync + 'a
+    where
+        Self: Sized,
+    {
+        let src_pid = self.vid();
+        match dir {
+            Direction::OUT => Iter3::I(
+                self.out_edges(layer_id)
+                    .map(move |(v, e)| EdgeRef::new_outgoing(e, src_pid, v)),
+            ),
+            Direction::IN => Iter3::J(
+                self.inb_edges(layer_id)
+                    .map(move |(v, e)| EdgeRef::new_incoming(e, v, src_pid)),
+            ),
+            Direction::BOTH => Iter3::K(
+                self.out_edges_sorted(layer_id)
+                    .map(move |(v, e)| EdgeRef::new_outgoing(e, src_pid, v))
+                    .merge_by(
+                        self.inb_edges_sorted(layer_id)
+                            .map(move |(v, e)| EdgeRef::new_incoming(e, v, src_pid)),
+                        |e1, e2| e1.remote() < e2.remote(),
+                    )
+                    .dedup_by(|l, r| l.pid() == r.pid()),
+            ),
+        }
+    }
+
+    #[box_on_debug_lifetime]
+    fn edges_iter<'b>(
+        self,
+        layers_ids: &'b LayerIds,
+        dir: Direction,
+    ) -> impl Iterator<Item = EdgeRef> + Send + Sync + 'a
+    where
+        Self: Sized,
+    {
+        match layers_ids {
+            LayerIds::One(layer_id) => Iter4::I(self.edges_dir(*layer_id, dir)),
+            LayerIds::All => Iter4::J(self.edges_dir(STATIC_GRAPH_LAYER_ID, dir)),
+            LayerIds::Multiple(layers) => Iter4::K(
+                layers
+                    .into_iter()
+                    .map(|layer_id| self.edges_dir(layer_id, dir))
+                    .kmerge_by(|e1, e2| e1.remote() < e2.remote())
+                    .dedup_by(|l, r| l.pid() == r.pid()),
+            ),
+            LayerIds::None => Iter4::L(std::iter::empty()),
+        }
+    }
+
+    fn node_meta(&self) -> &Arc<Meta>;
+
+    fn temp_prop_rows(
+        self,
+        w: Option<Range<EventTime>>,
+    ) -> impl Iterator<Item = (EventTime, usize, Vec<(usize, Prop)>)> + 'a {
+        (0..self.internal_num_layers()).flat_map(move |layer_id| {
+            let w = w.clone();
+            let additions = self.node_additions(layer_id);
+            let additions = w
+                .clone()
+                .map(|w| Iter2::I1(additions.range(w).iter()))
+                .unwrap_or_else(|| Iter2::I2(additions.iter()));
+
+            let mut time_ordered_iter = self
+                .node_meta()
+                .temporal_prop_mapper()
+                .ids()
+                .map(move |prop_id| {
+                    self.temporal_prop_layer(LayerId(layer_id), prop_id)
+                        .iter_inner(w.clone())
+                        .map(move |(t, prop)| (t, (prop_id, prop)))
+                })
+                .kmerge_by(|(t1, (p_id1, _)), (t2, (p_id2, _))| (t1, p_id1) < (t2, p_id2))
+                .merge_join_by(additions, |(t1, _), t2| t1 <= t2)
+                .map(move |result| match result {
+                    either::Either::Left((l, (prop_id, prop))) => (l, Some((prop_id, prop))),
+                    either::Either::Right(r) => (r, None),
+                });
+
+            let mut done = false;
+            if let Some((mut current_time, maybe_prop)) = time_ordered_iter.next() {
+                let mut current_row = Vec::from_iter(maybe_prop);
+                Iter2::I2(std::iter::from_fn(move || {
+                    if done {
+                        return None;
+                    }
+                    for (t, maybe_prop) in time_ordered_iter.by_ref() {
+                        if t == current_time {
+                            current_row.extend(maybe_prop);
+                        } else {
+                            let mut row = std::mem::take(&mut current_row);
+                            row.sort_unstable_by(|(a, _), (b, _)| a.cmp(b));
+                            let out = Some((current_time, layer_id, row));
+                            current_row.extend(maybe_prop);
+                            current_time = t;
+                            return out;
+                        }
+                    }
+                    done = true;
+                    let row = std::mem::take(&mut current_row);
+                    Some((current_time, layer_id, row))
+                }))
+            } else {
+                Iter2::I1(std::iter::empty())
+            }
+        })
+    }
+
+    fn out_nbrs(self, layer_id: LayerId) -> impl Iterator<Item = VID> + 'a
+    where
+        Self: Sized,
+    {
+        self.out_edges(layer_id).map(|(v, _)| v)
+    }
+
+    fn inb_nbrs(self, layer_id: LayerId) -> impl Iterator<Item = VID> + 'a
+    where
+        Self: Sized,
+    {
+        self.inb_edges(layer_id).map(|(v, _)| v)
+    }
+
+    fn out_nbrs_sorted(self, layer_id: LayerId) -> impl Iterator<Item = VID> + 'a
+    where
+        Self: Sized,
+    {
+        self.out_edges_sorted(layer_id).map(|(v, _)| v)
+    }
+
+    fn inb_nbrs_sorted(self, layer_id: LayerId) -> impl Iterator<Item = VID> + 'a
+    where
+        Self: Sized,
+    {
+        self.inb_edges_sorted(layer_id).map(|(v, _)| v)
+    }
+
+    fn edge_additions<L: Into<LayerIter<'a>>>(self, layer_id: L) -> Self::EdgeAdditions;
+
+    fn node_additions<L: Into<LayerIter<'a>>>(self, layer_id: L) -> Self::Additions;
+
+    fn c_prop(self, layer_id: LayerId, prop_id: usize) -> Option<Prop>;
+
+    fn c_prop_str(self, layer_id: LayerId, prop_id: usize) -> Option<&'a str>;
+
+    fn temporal_prop_layer(self, layer_id: LayerId, prop_id: usize) -> Self::TProps;
+
+    fn degree(self, layers: &LayerIds, dir: Direction) -> usize;
+
+    fn find_edge(&self, dst: VID, layers: &LayerIds) -> Option<EdgeRef>;
+
+    fn name(&self) -> Cow<'a, str> {
+        self.gid().to_str()
+    }
+
+    fn gid(&self) -> GidRef<'a> {
+        self.c_prop_str(LayerId(0), NODE_ID_IDX)
+            .map(GidRef::Str)
+            .or_else(|| {
+                self.c_prop(LayerId(0), NODE_ID_IDX)
+                    .and_then(|prop| prop.into_u64().map(GidRef::U64))
+            })
+            .unwrap_or_else(|| panic!("GID should be present, for node {:?}", self.vid()))
+    }
+
+    fn node_type_id(&self) -> usize {
+        self.c_prop(LayerId(0), NODE_TYPE_IDX)
+            .and_then(|prop| prop.into_u64())
+            .map_or(0, |id| id as usize)
+    }
+
+    fn internal_num_layers(&self) -> usize;
+
+    fn has_layer_inner(self, layer_id: LayerId) -> bool;
+}
diff --git a/db4-storage/src/dir/mod.rs b/db4-storage/src/dir/mod.rs
new file mode 100644
index 0000000000..1d7162c92f
--- /dev/null
+++ b/db4-storage/src/dir/mod.rs
@@ -0,0 +1,47 @@
+use std::{
+    io,
+    path::{Path, PathBuf},
+};
+use tempfile::TempDir;
+
+#[derive(Debug)]
+pub enum GraphDir {
+    Temp(TempDir),
+    Path(PathBuf),
+}
+
+impl GraphDir {
+    pub fn path(&self) -> &Path {
+        match self {
+            GraphDir::Temp(dir) => dir.path(),
+            GraphDir::Path(path) => path,
+        }
+    }
+    pub fn gid_resolver_dir(&self) -> PathBuf {
+        self.path().join("gid_resolver")
+    }
+
+    pub fn wal_dir(&self) -> PathBuf {
+        self.path().join("wal")
+    }
+
+    pub fn create_dir(&self) -> Result<(), io::Error> {
+        if let GraphDir::Path(path) = self {
+            std::fs::create_dir_all(path)?;
+        }
+
+        Ok(())
+    }
+}
+
+impl AsRef<Path> for GraphDir {
+    fn as_ref(&self) -> &Path {
+        self.path()
+    }
+}
+
+impl<'a> From<&'a Path> for GraphDir {
+    fn from(path: &'a Path) -> Self {
+        GraphDir::Path(path.to_path_buf())
+    }
+}
diff --git a/db4-storage/src/gen_ts.rs b/db4-storage/src/gen_ts.rs
new file mode 100644
index 0000000000..61b04bb6a2
--- /dev/null
+++ b/db4-storage/src/gen_ts.rs
@@ -0,0 +1,393 @@
+use std::ops::Range;
+
+use itertools::Itertools;
+use raphtory_api::core::entities::LayerId;
+use raphtory_core::{
+    entities::{ELID, LayerIds, layers::Multiple},
+    storage::timeindex::{EventTime, TimeIndexOps},
+};
+
+use crate::{NodeEntryRef, segments::additions::MemAdditions, utils::Iter3};
+
+#[derive(Clone, Debug)]
+pub enum LayerIter<'a> {
+    One(LayerId),
+    LRef(&'a LayerIds),
+    Multiple(Multiple),
+}
+
+pub static ALL_LAYERS: LayerIter<'static> = LayerIter::LRef(&LayerIds::All);
+pub static NONE_LAYERS: LayerIter<'static> = LayerIter::LRef(&LayerIds::None);
+
+impl<'a> LayerIter<'a> {
+    pub fn into_iter(self, num_layers: usize) -> impl Iterator<Item = LayerId> + Send + Sync + 'a {
+        match self {
+            LayerIter::One(id) => Iter3::I(std::iter::once(id)),
+            LayerIter::LRef(layers) => Iter3::J(layers.iter(num_layers)),
+            LayerIter::Multiple(ids) => Iter3::K(ids.into_iter()),
+        }
+    }
+}
+
+impl From<usize> for LayerIter<'_> {
+    fn from(id: usize) -> Self {
+        LayerIter::One(LayerId(id))
+    }
+}
+
+impl From<LayerId> for LayerIter<'_> {
+    fn from(id: LayerId) -> Self {
+        LayerIter::One(id)
+    }
+}
+
+impl<'a> From<&'a LayerIds> for LayerIter<'a> {
+    fn from(layers: &'a LayerIds) -> Self {
+        LayerIter::LRef(layers)
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct GenericTimeOps<'a, Ref> {
+    range: Option<(EventTime, EventTime)>,
+    layer_id: LayerIter<'a>,
+    item_ref: Ref,
+}
+
+impl<'a, Ref> GenericTimeOps<'a, Ref> {
+    pub fn new_with_layer(node: Ref, layer_id: impl Into<LayerIter<'a>>) -> Self {
+        Self {
+            range: None,
+            layer_id: layer_id.into(),
+            item_ref: node,
+        }
+    }
+}
+
+pub trait WithTimeCells<'a>: Copy + Clone + Send + Sync + std::fmt::Debug
+where
+    Self: 'a,
+{
+    type TimeCell: TimeIndexOps<'a, IndexType = EventTime>;
+
+    fn t_props_tc(
+        self,
+        layer_id: LayerId,
+        range: Option<(EventTime, EventTime)>,
+    ) -> impl Iterator<Item = Self::TimeCell> + Send + Sync + 'a;
+
+    fn additions_tc(
+        self,
+        layer_id: LayerId,
+        range: Option<(EventTime, EventTime)>,
+    ) -> impl Iterator<Item = Self::TimeCell> + Send + Sync + 'a;
+
+    fn deletions_tc(
+        self,
+        layer_id: LayerId,
+        range: Option<(EventTime, EventTime)>,
+    ) -> impl Iterator<Item = Self::TimeCell> + Send + Sync + 'a;
+
+    fn num_layers(&self) -> usize;
+}
+
+pub trait WithEdgeEvents<'a>: WithTimeCells<'a> {
+    type TimeCell: EdgeEventOps<'a>;
+}
+
+impl<'a> WithEdgeEvents<'a> for NodeEntryRef<'a> {
+    type TimeCell = MemAdditions<'a>;
+}
+
+pub trait EdgeEventOps<'a>: TimeIndexOps<'a, IndexType = EventTime> {
+    fn edge_events(self) -> impl Iterator<Item = (EventTime, ELID)> + Send + Sync + 'a;
+    fn edge_events_rev(self) -> impl Iterator<Item = (EventTime, ELID)> + Send + Sync + 'a;
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct AdditionCellsRef<'a, Ref: WithTimeCells<'a> + 'a> {
+    node: Ref,
+    _mark: std::marker::PhantomData<&'a ()>,
+}
+
+impl<'a, Ref: WithTimeCells<'a> + 'a> AdditionCellsRef<'a, Ref> {
+    pub fn new(node: Ref) -> Self {
+        Self {
+            node,
+            _mark: std::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, Ref: WithTimeCells<'a> + 'a> WithTimeCells<'a> for AdditionCellsRef<'a, Ref> {
+    type TimeCell = Ref::TimeCell;
+
+    fn t_props_tc(
+        self,
+        layer_id: LayerId,
+        range: Option<(EventTime, EventTime)>,
+    ) -> impl Iterator<Item = Self::TimeCell> + 'a {
+        self.node.t_props_tc(layer_id, range) // Assuming t_props_tc is not used for additions
+    }
+
+    fn additions_tc(
+        self,
+        _layer_id: LayerId,
+        _range: Option<(EventTime, EventTime)>,
+    ) -> impl Iterator<Item = Self::TimeCell> + 'a {
+        std::iter::empty()
+    }
+
+    fn deletions_tc(
+        self,
+        _layer_id: LayerId,
+        _range: Option<(EventTime, EventTime)>,
+    ) -> impl Iterator<Item = Self::TimeCell> + 'a {
+        std::iter::empty()
+    }
+
+    fn num_layers(&self) -> usize {
+        self.node.num_layers()
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct DeletionCellsRef<'a, Ref: WithTimeCells<'a> + 'a> {
+    node: Ref,
+    _mark: std::marker::PhantomData<&'a ()>,
+}
+
+impl<'a, Ref: WithTimeCells<'a> + 'a> DeletionCellsRef<'a, Ref> {
+    pub fn new(node: Ref) -> Self {
+        Self {
+            node,
+            _mark: std::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, Ref: WithTimeCells<'a> + 'a> WithTimeCells<'a> for DeletionCellsRef<'a, Ref> {
+    type TimeCell = Ref::TimeCell;
+
+    fn t_props_tc(
+        self,
+        _layer_id: LayerId,
+        _range: Option<(EventTime, EventTime)>,
+    ) -> impl Iterator<Item = Self::TimeCell> + 'a {
+        std::iter::empty()
+    }
+
+    fn additions_tc(
+        self,
+        _layer_id: LayerId,
+        _range: Option<(EventTime, EventTime)>,
+    ) -> impl Iterator<Item = Self::TimeCell> + 'a {
+        std::iter::empty()
+    }
+
+    fn deletions_tc(
+        self,
+        layer_id: LayerId,
+        range: Option<(EventTime, EventTime)>,
+    ) -> impl Iterator<Item = Self::TimeCell> + 'a {
+        self.node.deletions_tc(layer_id, range)
+    }
+
+    fn num_layers(&self) -> usize {
+        self.node.num_layers()
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct EdgeAdditionCellsRef<'a, Ref: WithTimeCells<'a> + 'a> {
+    node: Ref,
+    _mark: std::marker::PhantomData<&'a ()>,
+}
+
+impl<'a, Ref: WithTimeCells<'a> + 'a> EdgeAdditionCellsRef<'a, Ref> {
+    pub fn new(node: Ref) -> Self {
+        Self {
+            node,
+            _mark: std::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, Ref: WithTimeCells<'a> + 'a> WithTimeCells<'a> for EdgeAdditionCellsRef<'a, Ref> {
+    type TimeCell = Ref::TimeCell;
+
+    fn t_props_tc(
+        self,
+        _layer_id: LayerId,
+        _range: Option<(EventTime, EventTime)>,
+    ) -> impl Iterator<Item = Self::TimeCell> + 'a {
+        std::iter::empty()
+    }
+
+    fn additions_tc(
+        self,
+        layer_id: LayerId,
+        range: Option<(EventTime, EventTime)>,
+    ) -> impl Iterator<Item = Self::TimeCell> + 'a {
+        self.node.additions_tc(layer_id, range)
+    }
+
+    fn deletions_tc(
+        self,
+        _layer_id: LayerId,
+        _range: Option<(EventTime, EventTime)>,
+    ) -> impl Iterator<Item = Self::TimeCell> + 'a {
+        std::iter::empty()
+    }
+
+    fn num_layers(&self) -> usize {
+        self.node.num_layers()
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct PropAdditionCellsRef<'a, Ref: WithTimeCells<'a> + 'a> {
+    node: Ref,
+    _mark: std::marker::PhantomData<&'a ()>,
+}
+
+impl<'a, Ref: WithTimeCells<'a> + 'a> PropAdditionCellsRef<'a, Ref> {
+    pub fn new(node: Ref) -> Self {
+        Self {
+            node,
+            _mark: std::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, Ref: WithTimeCells<'a> + 'a> WithTimeCells<'a> for PropAdditionCellsRef<'a, Ref> {
+    type TimeCell = Ref::TimeCell;
+
+    fn t_props_tc(
+        self,
+        layer_id: LayerId,
+        range: Option<(EventTime, EventTime)>,
+    ) -> impl Iterator<Item = Self::TimeCell> + 'a {
+        self.node.t_props_tc(layer_id, range)
+    }
+
+    fn additions_tc(
+        self,
+        _layer_id: LayerId,
+        _range: Option<(EventTime, EventTime)>,
+    ) -> impl Iterator<Item = Self::TimeCell> + 'a {
+        std::iter::empty()
+    }
+
+    fn deletions_tc(
+        self,
+        _layer_id: LayerId,
+        _range: Option<(EventTime, EventTime)>,
+    ) -> impl Iterator<Item = Self::TimeCell> + 'a {
+        std::iter::empty()
+    }
+
+    fn num_layers(&self) -> usize {
+        self.node.num_layers()
+    }
+}
+
+impl<'a, Ref: WithEdgeEvents<'a> + 'a> GenericTimeOps<'a, EdgeAdditionCellsRef<'a, Ref>>
+where
+    <Ref as WithTimeCells<'a>>::TimeCell: EdgeEventOps<'a>,
+{
+    pub fn edge_events(self) -> impl Iterator<Item = (EventTime, ELID)> + Send + Sync + 'a {
+        self.layer_id
+            .into_iter(self.item_ref.num_layers())
+            .flat_map(move |layer_id| {
+                self.item_ref
+                    .additions_tc(layer_id, self.range)
+                    .map(|t_cell| t_cell.edge_events())
+            })
+            .kmerge_by(|a, b| a < b)
+    }
+
+    pub fn edge_events_rev(self) -> impl Iterator<Item = (EventTime, ELID)> + Send + Sync + 'a {
+        self.layer_id
+            .into_iter(self.item_ref.num_layers())
+            .flat_map(|layer_id| {
+                self.item_ref
+                    .additions_tc(layer_id, self.range)
+                    .map(|t_cell| t_cell.edge_events_rev())
+            })
+            .kmerge_by(|a, b| a > b)
+    }
+}
+
+impl<'a, Ref: WithTimeCells<'a> + 'a> GenericTimeOps<'a, Ref> {
+    pub fn time_cells(self) -> impl Iterator<Item = Ref::TimeCell> + Send + Sync + 'a {
+        let range = self.range;
+        self.layer_id
+            .into_iter(self.item_ref.num_layers())
+            .flat_map(move |layer_id| {
+                self.item_ref.t_props_tc(layer_id, range).chain(
+                    self.item_ref
+                        .additions_tc(layer_id, range)
+                        .chain(self.item_ref.deletions_tc(layer_id, range)),
+                )
+            })
+    }
+
+    fn into_iter(self) -> impl Iterator<Item = EventTime> + Send + Sync + 'a {
+        let iters = self.time_cells();
+        iters.map(|cell| cell.iter()).kmerge()
+    }
+
+    fn into_iter_rev(self) -> impl Iterator<Item = EventTime> + Send + Sync + 'a {
+        let iters = self.time_cells();
+        iters.map(|cell| cell.iter_rev()).kmerge_by(|a, b| a > b)
+    }
+}
+
+impl<'a, Ref: WithTimeCells<'a> + 'a> TimeIndexOps<'a> for GenericTimeOps<'a, Ref> {
+    type IndexType = EventTime;
+
+    type RangeType = Self;
+
+    fn active(&self, w: Range<Self::IndexType>) -> bool {
+        self.clone()
+            .time_cells()
+            .any(|t_cell| t_cell.active(w.clone()))
+    }
+
+    fn range(&self, w: Range<Self::IndexType>) -> Self::RangeType {
+        GenericTimeOps {
+            range: Some((w.start, w.end)),
+            item_ref: self.item_ref,
+            layer_id: self.layer_id.clone(),
+        }
+    }
+
+    fn first(&self) -> Option<Self::IndexType> {
+        Iterator::min(
+            self.clone()
+                .time_cells()
+                .filter_map(|t_cell| t_cell.first()),
+        )
+    }
+
+    fn last(&self) -> Option<Self::IndexType> {
+        Iterator::max(self.clone().time_cells().filter_map(|t_cell| t_cell.last()))
+    }
+
+    fn iter(self) -> impl Iterator<Item = Self::IndexType> + Send + Sync + 'a {
+        self.into_iter()
+    }
+
+    fn iter_rev(self) -> impl Iterator<Item = Self::IndexType> + Send + Sync + 'a {
+        self.into_iter_rev()
+    }
+
+    fn len(&self) -> usize {
+        self.clone().time_cells().map(|t_cell| t_cell.len()).sum()
+    }
+
+    fn is_empty(&self) -> bool {
+        self.clone().time_cells().all(|t_cell| t_cell.is_empty())
+    }
+}
diff --git a/db4-storage/src/generic_t_props.rs b/db4-storage/src/generic_t_props.rs
new file mode 100644
index 0000000000..e2d96955e9
--- /dev/null
+++ b/db4-storage/src/generic_t_props.rs
@@ -0,0 +1,133 @@
+use std::{borrow::Borrow, ops::Range};
+
+use either::Either;
+use itertools::Itertools;
+use raphtory_api::core::entities::{
+    LayerId,
+    properties::{prop::Prop, tprop::TPropOps},
+};
+use raphtory_api_macros::box_on_debug_lifetime;
+use raphtory_core::{entities::LayerIds, storage::timeindex::EventTime};
+
+use crate::utils::Iter4;
+
+/// `WithTProps` defines behavior for types that store multiple temporal
+/// properties either in memory or on disk.
+///
+/// Used by `GenericTProps` to implement `TPropOps` for such types.
+pub trait WithTProps<'a>: Clone + Copy + Send + Sync
+where
+    Self: 'a,
+{
+    type TProp: TPropOps<'a>;
+
+    fn num_layers(&self) -> usize;
+
+    fn into_t_props(
+        self,
+        layer_id: LayerId,
+        prop_id: usize,
+    ) -> impl Iterator<Item = Self::TProp> + Send + Sync + 'a;
+
+    #[box_on_debug_lifetime]
+    fn into_t_props_layers(
+        self,
+        layers: impl Borrow<LayerIds>,
+        prop_id: usize,
+    ) -> impl Iterator<Item = Self::TProp> + Send + Sync + 'a {
+        match layers.borrow() {
+            LayerIds::None => Iter4::I(std::iter::empty()),
+            LayerIds::One(layer_id) => Iter4::J(self.into_t_props(*layer_id, prop_id)),
+            LayerIds::All => Iter4::K(
+                (0..self.num_layers())
+                    .map(LayerId)
+                    .flat_map(move |layer_id| self.into_t_props(layer_id, prop_id)),
+            ),
+            LayerIds::Multiple(layers) => Iter4::L(
+                layers
+                    .clone()
+                    .into_iter()
+                    .flat_map(move |layer_id| self.into_t_props(layer_id, prop_id)),
+            ),
+        }
+    }
+}
+
+/// A generic implementation of `TPropOps` that aggregates temporal properties
+/// across storage.
+///
+/// Wraps types implementing `WithTProps` (eg, `MemNodeRef`, `DiskNodeRef`)
+/// to provide unified access to temporal properties. Also handles k-merging
+/// temporal properties when queried.
+#[derive(Clone, Copy)]
+pub struct GenericTProps<'a, Ref: WithTProps<'a>> {
+    reference: Ref,
+    layer_id: Either<&'a LayerIds, LayerId>,
+    prop_id: usize,
+}
+
+impl<'a, Ref: WithTProps<'a>> GenericTProps<'a, Ref> {
+    pub fn new(reference: Ref, layer_id: &'a LayerIds, prop_id: usize) -> Self {
+        Self {
+            reference,
+            layer_id: Either::Left(layer_id),
+            prop_id,
+        }
+    }
+
+    pub fn new_with_layer(reference: Ref, layer_id: LayerId, prop_id: usize) -> Self {
+        Self {
+            reference,
+            layer_id: Either::Right(layer_id),
+            prop_id,
+        }
+    }
+}
+
+impl<'a, Ref: WithTProps<'a>> GenericTProps<'a, Ref> {
+    #[box_on_debug_lifetime]
+    fn tprops(self, prop_id: usize) -> impl Iterator<Item = Ref::TProp> + Send + Sync + 'a {
+        match self.layer_id {
+            Either::Left(layer_ids) => {
+                Either::Left(self.reference.into_t_props_layers(layer_ids, prop_id))
+            }
+            Either::Right(layer_id) => {
+                Either::Right(self.reference.into_t_props(layer_id, prop_id))
+            }
+        }
+    }
+}
+
+impl<'a, Ref: WithTProps<'a>> TPropOps<'a> for GenericTProps<'a, Ref> {
+    fn last_before(&self, t: EventTime) -> Option<(EventTime, Prop)> {
+        self.tprops(self.prop_id)
+            .filter_map(|t_props| t_props.last_before(t))
+            .max_by_key(|(t, _)| *t)
+    }
+
+    fn iter_inner(
+        self,
+        w: Option<Range<EventTime>>,
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'a {
+        let tprops = self.tprops(self.prop_id);
+        tprops
+            .map(|t_prop| t_prop.iter_inner(w.clone()))
+            .kmerge_by(|(a, _), (b, _)| a < b)
+    }
+
+    fn iter_inner_rev(
+        self,
+        w: Option<Range<EventTime>>,
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'a {
+        let tprops = self
+            .tprops(self.prop_id)
+            .map(move |t_cell| t_cell.iter_inner_rev(w.clone()));
+        tprops.kmerge_by(|(a, _), (b, _)| a > b)
+    }
+
+    fn at(&self, ti: &EventTime) -> Option<Prop> {
+        self.tprops(self.prop_id)
+            .flat_map(|t_props| t_props.at(ti))
+            .next() // TODO: need to figure out how to handle this
+    }
+}
diff --git a/db4-storage/src/lib.rs b/db4-storage/src/lib.rs
new file mode 100644
index 0000000000..623737957a
--- /dev/null
+++ b/db4-storage/src/lib.rs
@@ -0,0 +1,215 @@
+use crate::{
+    gen_ts::{
+        AdditionCellsRef, DeletionCellsRef, EdgeAdditionCellsRef, GenericTimeOps,
+        PropAdditionCellsRef,
+    },
+    generic_t_props::GenericTProps,
+    pages::{
+        GraphStore, ReadLockedGraphStore, edge_store::ReadLockedEdgeStorage,
+        node_store::ReadLockedNodeStorage,
+    },
+    persist::strategy::{NoOpStrategy, PersistenceStrategy},
+    resolver::mapping_resolver::MappingResolver,
+    segments::{
+        edge::{
+            entry::{MemEdgeEntry, MemEdgeRef},
+            segment::EdgeSegmentView,
+        },
+        graph_prop::entry::{MemGraphPropEntry, MemGraphPropRef},
+        node::{
+            entry::{MemNodeEntry, MemNodeRef},
+            segment::NodeSegmentView,
+        },
+    },
+};
+use parking_lot::RwLock;
+use raphtory_api::core::entities::{EID, VID};
+use segments::{
+    edge::segment::MemEdgeSegment, graph_prop::GraphPropSegmentView, node::segment::MemNodeSegment,
+};
+use std::{
+    path::{Path, PathBuf},
+    thread,
+    time::Duration,
+};
+
+pub mod api;
+pub mod dir;
+pub mod gen_ts;
+pub mod generic_t_props;
+pub mod pages;
+pub mod persist;
+pub mod properties;
+pub mod resolver;
+pub mod segments;
+pub mod state;
+pub mod transaction;
+pub mod utils;
+pub mod wal;
+
+pub type Extension = NoOpStrategy;
+pub type NS<P> = NodeSegmentView<P>;
+pub type ES<P> = EdgeSegmentView<P>;
+pub type GS<P> = GraphPropSegmentView<P>;
+pub type Layer<P> = GraphStore<NS<P>, ES<P>, GS<P>, P>;
+
+pub type Wal = <Extension as PersistenceStrategy>::Wal;
+pub type ControlFile = <Extension as PersistenceStrategy>::ControlFile;
+pub type Config = <Extension as PersistenceStrategy>::Config;
+pub type GIDResolver = MappingResolver;
+
+pub type ReadLockedLayer<P> = ReadLockedGraphStore<NS<P>, ES<P>, GS<P>, P>;
+pub type ReadLockedNodes<P> = ReadLockedNodeStorage<NS<P>, P>;
+pub type ReadLockedEdges<P> = ReadLockedEdgeStorage<ES<P>, P>;
+
+pub type NodeEntry<'a> = MemNodeEntry<'a, parking_lot::RwLockReadGuard<'a, MemNodeSegment>>;
+pub type EdgeEntry<'a> = MemEdgeEntry<'a, parking_lot::RwLockReadGuard<'a, MemEdgeSegment>>;
+pub type GraphPropEntry<'a> = MemGraphPropEntry<'a>;
+pub type NodeEntryRef<'a> = MemNodeRef<'a>;
+pub type EdgeEntryRef<'a> = MemEdgeRef<'a>;
+pub type GraphPropEntryRef<'a> = MemGraphPropRef<'a>;
+
+pub type NodePropAdditions<'a> = GenericTimeOps<'a, PropAdditionCellsRef<'a, MemNodeRef<'a>>>;
+pub type NodeEdgeAdditions<'a> = GenericTimeOps<'a, EdgeAdditionCellsRef<'a, MemNodeRef<'a>>>;
+
+pub type EdgeAdditions<'a> = GenericTimeOps<'a, AdditionCellsRef<'a, MemEdgeRef<'a>>>;
+pub type EdgeDeletions<'a> = GenericTimeOps<'a, DeletionCellsRef<'a, MemEdgeRef<'a>>>;
+
+pub type NodeTProps<'a> = GenericTProps<'a, MemNodeRef<'a>>;
+pub type EdgeTProps<'a> = GenericTProps<'a, MemEdgeRef<'a>>;
+pub type GraphTProps<'a> = GenericTProps<'a, MemGraphPropRef<'a>>;
+
+pub mod error {
+    use std::{io, panic::Location, path::PathBuf, sync::Arc};
+
+    use crate::resolver::mapping_resolver::InvalidNodeId;
+    use raphtory_api::core::{entities::properties::prop::PropError, utils::time::ParseTimeError};
+    use raphtory_core::entities::properties::props::MetadataError;
+
+    #[derive(thiserror::Error, Debug)]
+    pub enum StorageError {
+        #[error("External Storage Error {0}")]
+        External(#[from] Arc<dyn std::error::Error + Send + Sync>),
+        #[error("{source} at {location}")]
+        IO {
+            source: io::Error,
+            location: &'static Location<'static>,
+        },
+        #[error("Serde error: {0}")]
+        Serde(#[from] serde_json::Error),
+        #[error("Arrow-rs error: {0}")]
+        ArrowRS(#[from] arrow_schema::ArrowError),
+        #[error("Parquet error: {0}")]
+        Parquet(#[from] parquet::errors::ParquetError),
+        #[error(transparent)]
+        PropError(#[from] PropError),
+        #[error(transparent)]
+        MetadataError(#[from] MetadataError),
+        #[error("Empty Graph: {0}")]
+        EmptyGraphDir(PathBuf),
+        #[error("Failed to parse time string")]
+        ParseTime {
+            #[from]
+            source: ParseTimeError,
+        },
+        // #[error("Failed to mutate: {0}")]
+        // MutationError(#[from] MutationError),
+        #[error("Unnamed Failure: {0}")]
+        GenericFailure(String),
+        #[error(transparent)]
+        InvalidNodeId(#[from] InvalidNodeId),
+
+        #[error("Failed to vacuum storage")]
+        VacuumError,
+
+        #[error("Disk storage not supported")]
+        DiskStorageNotSupported,
+    }
+
+    impl StorageError {
+        pub fn from_external<E: std::error::Error + Send + Sync + 'static>(error: E) -> Self {
+            Self::External(Arc::new(error))
+        }
+    }
+
+    impl From<io::Error> for StorageError {
+        #[track_caller]
+        fn from(source: io::Error) -> Self {
+            let location = Location::caller();
+            StorageError::IO { source, location }
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, serde::Serialize)]
+#[repr(transparent)]
+pub struct LocalPOS(pub u32);
+
+impl From<usize> for LocalPOS {
+    fn from(value: usize) -> Self {
+        assert!(value <= u32::MAX as usize);
+        LocalPOS(value as u32)
+    }
+}
+
+impl LocalPOS {
+    pub fn as_vid(self, page_id: usize, max_page_len: u32) -> VID {
+        VID(page_id * (max_page_len as usize) + (self.0 as usize))
+    }
+
+    pub fn as_eid(self, page_id: usize, max_page_len: u32) -> EID {
+        EID(page_id * (max_page_len as usize) + (self.0 as usize))
+    }
+
+    pub fn as_index(self) -> usize {
+        self.0 as usize
+    }
+}
+
+pub fn calculate_size_recursive(path: &Path) -> Result<usize, std::io::Error> {
+    let mut size = 0;
+    if path.is_dir() {
+        for entry in std::fs::read_dir(path)? {
+            let entry = entry?;
+            let path = entry.path();
+            if path.is_dir() {
+                size += calculate_size_recursive(&path)?;
+            } else {
+                size += path.metadata()?.len() as usize;
+            }
+        }
+    } else {
+        size += path.metadata()?.len() as usize;
+    }
+    Ok(size)
+}
+
+pub fn collect_tree_paths(path: &Path) -> Vec<PathBuf> {
+    let mut paths = Vec::new();
+    if path.is_dir() {
+        for entry in std::fs::read_dir(path).unwrap() {
+            let entry = entry.unwrap();
+            let entry_path = entry.path();
+            if entry_path.is_dir() {
+                paths.extend(collect_tree_paths(&entry_path));
+            } else {
+                paths.push(entry_path);
+            }
+        }
+    } else {
+        paths.push(path.to_path_buf());
+    }
+    paths
+}
+
+pub fn loop_lock_write<A>(l: &RwLock<A>) -> parking_lot::RwLockWriteGuard<'_, A> {
+    const MAX_BACKOFF_US: u64 = 1000; // 1ms max
+    let mut backoff_us = 1;
+    loop {
+        if let Some(guard) = l.try_write_for(Duration::from_micros(50)) {
+            return guard;
+        }
+        thread::park_timeout(Duration::from_micros(backoff_us));
+        backoff_us = (backoff_us * 2).min(MAX_BACKOFF_US);
+    }
+}
diff --git a/db4-storage/src/loaders/mod.rs b/db4-storage/src/loaders/mod.rs
new file mode 100644
index 0000000000..7a2c1f2f00
--- /dev/null
+++ b/db4-storage/src/loaders/mod.rs
@@ -0,0 +1,516 @@
+use crate::{EdgeSegmentOps, NodeSegmentOps, error::StorageError, pages::GraphStore};
+use arrow::buffer::ScalarBuffer;
+use arrow_array::{
+    Array, PrimitiveArray, RecordBatch, TimestampMicrosecondArray, TimestampMillisecondArray,
+    TimestampNanosecondArray, types::Int64Type,
+};
+use arrow_csv::reader::Format;
+use arrow_schema::{ArrowError, DataType, Schema, TimeUnit};
+use bytemuck::checked::cast_slice_mut;
+use either::Either;
+use parquet::arrow::arrow_reader::ParquetRecordBatchReaderBuilder;
+use raphtory_api::core::{
+    entities::properties::prop::PropType,
+    storage::{dict_mapper::MaybeNew, timeindex::TimeIndexEntry},
+};
+use raphtory_core::entities::{EID, VID, graph::logical_to_physical::Mapping};
+use rayon::prelude::*;
+use std::{
+    fs::File,
+    path::{Path, PathBuf},
+    sync::{
+        Arc,
+        atomic::{self, AtomicBool, AtomicUsize},
+    },
+};
+
+pub struct Loader<'a> {
+    path: PathBuf,
+    src_col: Either<&'a str, usize>,
+    dst_col: Either<&'a str, usize>,
+    time_col: Either<&'a str, usize>,
+    format: FileFormat,
+}
+
+pub enum FileFormat {
+    CSV {
+        delimiter: u8,
+        has_header: bool,
+        sample_records: usize,
+    },
+    Parquet,
+}
+
+pub struct Rows {
+    rb: RecordBatch,
+    src: usize,
+    dst: usize,
+    t_properties: Vec<String>,
+    t_indices: Vec<usize>,
+    time_col: ScalarBuffer<i64>,
+}
+
+impl Rows {
+    pub fn srcs(&self) -> Result<NodeCol, StorageError> {
+        let arr = self.rb.column(self.src);
+        let arr = arr.as_ref();
+        let srcs = NodeCol::try_from(arr)?;
+        Ok(srcs)
+    }
+
+    pub fn dsts(&self) -> Result<NodeCol, StorageError> {
+        let arr = self.rb.column(self.dst);
+        let arr = arr.as_ref();
+        let dsts = NodeCol::try_from(arr)?;
+        Ok(dsts)
+    }
+
+    pub fn time(&self) -> &[i64] {
+        &self.time_col
+    }
+
+    pub fn properties(
+        &self,
+        prop_id_resolver: impl Fn(&str, PropType) -> Result<MaybeNew<usize>, StorageError>,
+    ) -> Result<PropCols, StorageError> {
+        combine_properties_arrow(
+            &self.t_properties,
+            &self.t_indices,
+            self.rb.columns(),
+            prop_id_resolver,
+        )
+    }
+
+    fn new(rb: RecordBatch, src: usize, dst: usize, time: usize) -> Result<Self, StorageError> {
+        let (t_indices, t_properties): (Vec<_>, Vec<_>) = rb
+            .schema()
+            .fields()
+            .iter()
+            .enumerate()
+            .filter_map(|(id, f)| {
+                if id == src || id == dst || id == time {
+                    None
+                } else {
+                    Some((id, f.name().to_owned()))
+                }
+            })
+            .unzip();
+
+        let time_arr = rb.column(time);
+        let values = if let Some(arr) = time_arr
+            .as_any()
+            .downcast_ref::<PrimitiveArray<Int64Type>>()
+        {
+            arr.values().clone()
+        } else if let Some(arr) = time_arr.as_any().downcast_ref::<TimestampNanosecondArray>() {
+            let arr_to_millis =
+                arrow::compute::cast(&arr, &DataType::Timestamp(TimeUnit::Millisecond, None))?;
+            let arr = arr_to_millis
+                .as_any()
+                .downcast_ref::<TimestampMillisecondArray>()
+                .unwrap();
+            arr.values().clone()
+        } else if let Some(arr) = time_arr
+            .as_any()
+            .downcast_ref::<TimestampMicrosecondArray>()
+        {
+            let arr_to_millis =
+                arrow::compute::cast(&arr, &DataType::Timestamp(TimeUnit::Millisecond, None))?;
+            let arr = arr_to_millis
+                .as_any()
+                .downcast_ref::<TimestampMillisecondArray>()
+                .unwrap();
+            arr.values().clone()
+        } else if let Some(arr) = time_arr
+            .as_any()
+            .downcast_ref::<TimestampMillisecondArray>()
+        {
+            arr.values().clone()
+        } else {
+            return Err(StorageError::ArrowRS(ArrowError::CastError(format!(
+                "failed to cast time column {} to i64",
+                time_arr.data_type()
+            ))));
+        };
+
+        Ok(Self {
+            rb,
+            src,
+            dst,
+            t_indices,
+            t_properties,
+            time_col: values,
+        })
+    }
+
+    fn num_rows(&self) -> usize {
+        self.rb.num_rows()
+    }
+}
+
+impl<'a> Loader<'a> {
+    pub fn new(
+        path: &Path,
+        src_col: Either<&'a str, usize>,
+        dst_col: Either<&'a str, usize>,
+        time_col: Either<&'a str, usize>,
+        format: FileFormat,
+    ) -> Result<Self, StorageError> {
+        Ok(Self {
+            path: path.to_owned(),
+            src_col,
+            dst_col,
+            time_col,
+            format,
+        })
+    }
+
+    pub fn iter_file(
+        &self,
+        path: &Path,
+        rows_per_batch: usize,
+    ) -> Result<Box<dyn Iterator<Item = Result<Rows, StorageError>> + Send>, StorageError> {
+        match &self.format {
+            FileFormat::CSV {
+                delimiter,
+                has_header,
+                sample_records,
+            } => {
+                let file = File::open(path).unwrap();
+                let (schema, _) = Format::default()
+                    .with_header(*has_header)
+                    .with_delimiter(*delimiter)
+                    .infer_schema(file, Some(*sample_records))?;
+                let schema = Arc::new(schema);
+
+                let (src, dst, time) = self.src_dst_time_cols(&schema)?;
+
+                let file = File::open(path)?;
+
+                let reader = arrow_csv::reader::ReaderBuilder::new(schema.clone())
+                    .with_header(*has_header)
+                    .with_delimiter(*delimiter)
+                    .with_batch_size(rows_per_batch)
+                    .build(file)?;
+                Ok(Box::new(reader.map(move |rb| {
+                    rb.map_err(StorageError::from)
+                        .and_then(|rb| Rows::new(rb, src, dst, time))
+                })))
+            }
+            FileFormat::Parquet => {
+                let file = File::open(path)?;
+                let builder =
+                    ParquetRecordBatchReaderBuilder::try_new(file)?.with_batch_size(rows_per_batch);
+
+                let (src, dst, time) = self.src_dst_time_cols(&builder.schema())?;
+                let reader = builder.build()?;
+                Ok(Box::new(reader.map(move |rb| {
+                    rb.map_err(StorageError::from)
+                        .and_then(|rb| Rows::new(rb, src, dst, time))
+                })))
+            }
+        }
+    }
+
+    pub fn iter(
+        &self,
+        rows_per_batch: usize,
+    ) -> Result<Box<dyn Iterator<Item = Result<Rows, StorageError>> + Send>, StorageError> {
+        if self.path.is_dir() {
+            let mut files = vec![];
+            for entry in std::fs::read_dir(&self.path)? {
+                let entry = entry?;
+                if entry.file_type()?.is_file() {
+                    files.push(entry.path());
+                }
+            }
+            let iterators: Vec<_> = files
+                .into_iter()
+                .map(|path| self.iter_file(&path, rows_per_batch))
+                .collect::<Result<Vec<_>, _>>()?;
+            Ok(Box::new(iterators.into_iter().flatten()))
+        } else {
+            Ok(self.iter_file(&self.path, rows_per_batch)?)
+        }
+    }
+
+    fn src_dst_time_cols(&self, schema: &Schema) -> Result<(usize, usize, usize), StorageError> {
+        let src_field = match self.src_col {
+            Either::Left(name) => schema.index_of(name)?,
+            Either::Right(idx) => idx,
+        };
+        let dst_field = match self.dst_col {
+            Either::Left(name) => schema.index_of(name)?,
+            Either::Right(idx) => idx,
+        };
+
+        let time_field = match self.time_col {
+            Either::Left(name) => schema.index_of(name)?,
+            Either::Right(idx) => idx,
+        };
+
+        Ok((src_field, dst_field, time_field))
+    }
+
+    pub fn load_into<
+        NS: NodeSegmentOps<Extension = EXT>,
+        ES: EdgeSegmentOps<Extension = EXT>,
+        EXT: Clone + Default + Send + Sync,
+    >(
+        &self,
+        graph: &GraphStore<NS, ES, EXT>,
+        rows_per_batch: usize,
+    ) -> Result<Mapping, StorageError> {
+        let mut src_col_resolved: Vec<VID> = vec![];
+        let mut dst_col_resolved: Vec<VID> = vec![];
+        let mut eid_col_resolved: Vec<EID> = vec![];
+        let mut eids_exist: Vec<AtomicBool> = vec![]; // exists or needs to be created
+
+        let max_edge_id = AtomicUsize::new(graph.edges().num_edges().saturating_sub(1));
+
+        let resolver = Mapping::new();
+
+        let next_id = AtomicUsize::new(0);
+        let mut offset = 0;
+
+        let now = std::time::Instant::now();
+        for chunk in self.iter(rows_per_batch)? {
+            let now_chunk = std::time::Instant::now();
+            let rb = chunk?;
+
+            let props = rb.properties(|name, p_type| {
+                graph
+                    .edge_meta()
+                    .resolve_prop_id(name, p_type, false)
+                    .map_err(StorageError::from)
+            })?;
+
+            let srcs = rb.srcs()?;
+            let dsts = rb.dsts()?;
+
+            src_col_resolved.resize_with(rb.num_rows(), Default::default);
+            srcs.par_iter()
+                .zip(src_col_resolved.par_iter_mut())
+                .try_for_each(|(gid, resolved)| {
+                    let gid = gid.ok_or_else(|| LoadError::MissingSrcError)?;
+                    let id = resolver
+                        .get_or_init(gid, || VID(next_id.fetch_add(1, atomic::Ordering::Relaxed)))
+                        .unwrap()
+                        .inner();
+                    *resolved = id;
+                    Ok::<(), StorageError>(())
+                })?;
+
+            dst_col_resolved.resize_with(rb.num_rows(), Default::default);
+            dsts.par_iter()
+                .zip(dst_col_resolved.par_iter_mut())
+                .try_for_each(|(gid, resolved)| {
+                    let gid = gid.ok_or_else(|| LoadError::MissingDstError)?;
+                    let id = resolver
+                        .get_or_init(gid, || VID(next_id.fetch_add(1, atomic::Ordering::Relaxed)))
+                        .unwrap()
+                        .inner();
+                    *resolved = id;
+                    Ok::<(), StorageError>(())
+                })?;
+
+            eid_col_resolved.resize_with(rb.num_rows(), Default::default);
+            eids_exist.resize_with(rb.num_rows(), Default::default);
+            let eid_col_shared = atomic_usize_from_mut_slice(cast_slice_mut(&mut eid_col_resolved));
+
+            let num_pages =
+                next_id.load(atomic::Ordering::Relaxed) / graph.nodes().max_page_len() + 1;
+            graph.nodes().grow(num_pages);
+
+            let mut node_writers = graph.nodes().locked();
+
+            node_writers.par_iter_mut().try_for_each(|locked_page| {
+                for (row, (&src, &dst)) in src_col_resolved
+                    .iter()
+                    .zip(dst_col_resolved.iter())
+                    .enumerate()
+                {
+                    if let Some(src_pos) = locked_page.resolve_pos(src) {
+                        let mut writer = locked_page.writer();
+                        if let Some(edge_id) = writer.get_out_edge(src_pos, dst) {
+                            eid_col_shared[row].store(edge_id.0, atomic::Ordering::Relaxed);
+                            eids_exist[row].store(true, atomic::Ordering::Relaxed);
+                        } else {
+                            let edge_id = EID(max_edge_id.fetch_add(1, atomic::Ordering::Relaxed));
+                            writer.add_outbound_edge(0, src_pos, dst, edge_id.with_layer(0), 0); // FIXME: when we update this to work with layers use the correct layer
+                            eid_col_shared[row].store(edge_id.0, atomic::Ordering::Relaxed);
+                            eids_exist[row].store(false, atomic::Ordering::Relaxed);
+                        }
+                    }
+                }
+
+                Ok::<_, StorageError>(())
+            })?;
+
+            node_writers.par_iter_mut().try_for_each(|locked_page| {
+                for (&edge_id, (&src, &dst)) in eid_col_resolved
+                    .iter()
+                    .zip(src_col_resolved.iter().zip(&dst_col_resolved))
+                {
+                    if let Some(dst_pos) = locked_page.resolve_pos(dst) {
+                        let mut writer = locked_page.writer();
+                        if !writer.get_inb_edge(dst_pos, src).is_some() {
+                            let edge_id = EID(edge_id.0);
+                            writer.add_inbound_edge(0, dst_pos, src, edge_id.with_layer(0), 0); // FIXME: when we update this to work with layers use the correct layer
+                        }
+                    }
+                }
+
+                Ok::<_, StorageError>(())
+            })?;
+
+            // now edges
+
+            let num_pages =
+                max_edge_id.load(atomic::Ordering::Relaxed) / graph.edges().max_page_len() + 1;
+
+            graph.edges().grow(num_pages);
+
+            let mut edge_writers = graph.edges().locked();
+
+            let time_col = rb.time();
+
+            edge_writers.iter_mut().for_each(|edge_writer| {
+                for (row_idx, ((((&src, &dst), &eid), edge_exists), time)) in src_col_resolved
+                    .iter()
+                    .zip(&dst_col_resolved)
+                    .zip(&eid_col_resolved)
+                    .zip(
+                        eids_exist
+                            .iter()
+                            .map(|exists| exists.load(atomic::Ordering::Relaxed)),
+                    )
+                    .zip(time_col)
+                    .enumerate()
+                {
+                    if let Some(local_pos) = edge_writer.resolve_pos(eid) {
+                        let mut writer = edge_writer.writer();
+                        let time = TimeIndexEntry::new(*time, offset + row_idx);
+                        writer.add_edge(
+                            time,
+                            Some(local_pos),
+                            src,
+                            dst,
+                            props.iter_row(row_idx),
+                            0,
+                            Some(edge_exists),
+                        );
+                    }
+                }
+            });
+
+            src_col_resolved.clear();
+            dst_col_resolved.clear();
+            eid_col_resolved.clear();
+            eids_exist.clear();
+            offset += rb.num_rows();
+        }
+
+        Ok(resolver)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::{Layer, pages::test_utils::check_load_support};
+    use proptest::{collection::vec, prelude::*};
+
+    fn check_load(edges: &[(i64, u64, u64)], max_page_len: usize) {
+        check_load_support(edges, false, |path| {
+            Layer::<()>::new(path, max_page_len, max_page_len)
+        });
+    }
+
+    #[test]
+    fn test_one_edge() {
+        check_load(&[(0, 0, 1)], 32);
+    }
+
+    #[test]
+    fn test_load_graph_from_csv() {
+        let edge_strat = (1u64..100).prop_flat_map(|num_nodes| {
+            (1usize..100).prop_flat_map(move |num_edges| {
+                vec(((0i64..100), (0..num_nodes), (0..num_nodes)), num_edges)
+            })
+        });
+
+        proptest!(|(edges in edge_strat, max_page_len in 1usize .. 100)| {
+            check_load(&edges, max_page_len);
+        });
+    }
+
+    #[test]
+    fn teas_load_graph_from_csv_5() {
+        let edges = [
+            (42, 16, 24),
+            (96, 41, 8),
+            (37, 9, 9),
+            (62, 37, 57),
+            (12, 49, 23),
+            (8, 60, 44),
+            (56, 35, 0),
+            (9, 48, 58),
+            (59, 20, 37),
+            (36, 17, 46),
+        ];
+        let max_page_len = 7;
+        check_load(&edges, max_page_len);
+    }
+
+    #[test]
+    fn test_load_graph_from_csv_4() {
+        let edges = [
+            (27, 20, 85),
+            (2, 29, 77),
+            (55, 59, 22),
+            (72, 47, 73),
+            (26, 66, 36),
+            (22, 39, 37),
+            (5, 49, 88),
+            (2, 48, 13),
+            (97, 23, 57),
+        ];
+        let max_page_len = 8;
+        check_load(&edges, max_page_len);
+    }
+
+    #[test]
+    fn test_load_graph_from_csv_1() {
+        let edges = [(0, 33, 31), (1, 12, 20), (2, 22, 32)];
+
+        check_load(&edges, 32);
+    }
+
+    #[test]
+    fn test_load_graph_from_csv_2() {
+        let edges = [
+            (0, 23, 61),
+            (1, 52, 14),
+            (2, 62, 62),
+            (3, 13, 9),
+            (4, 29, 6),
+            (5, 13, 7),
+        ];
+
+        check_load(&edges, 5);
+    }
+
+    #[test]
+    fn test_load_graph_from_csv_3() {
+        let edges = [(0, 0, 32)];
+
+        check_load(&edges, 51);
+    }
+
+    #[test]
+    fn test_edges_1() {
+        let edges = [(0, 1, 0), (0, 0, 0), (0, 0, 0)];
+
+        check_load(&edges, 32);
+    }
+}
diff --git a/db4-storage/src/pages/edge_page/mod.rs b/db4-storage/src/pages/edge_page/mod.rs
new file mode 100644
index 0000000000..d3baa81782
--- /dev/null
+++ b/db4-storage/src/pages/edge_page/mod.rs
@@ -0,0 +1 @@
+pub mod writer;
diff --git a/db4-storage/src/pages/edge_page/writer.rs b/db4-storage/src/pages/edge_page/writer.rs
new file mode 100644
index 0000000000..87110e321e
--- /dev/null
+++ b/db4-storage/src/pages/edge_page/writer.rs
@@ -0,0 +1,240 @@
+use crate::{
+    LocalPOS,
+    api::edges::EdgeSegmentOps,
+    error::StorageError,
+    pages::{layer_counter::GraphStats, resolve_pos},
+    segments::edge::segment::MemEdgeSegment,
+    wal::LSN,
+};
+use raphtory_api::core::entities::{
+    EID, LayerId, VID,
+    properties::{
+        meta::STATIC_GRAPH_LAYER_ID,
+        prop::{AsPropRef, Prop},
+    },
+};
+use raphtory_core::storage::timeindex::{AsTime, EventTime};
+use std::ops::DerefMut;
+
+pub struct EdgeWriter<
+    'a,
+    MP: DerefMut<Target = MemEdgeSegment> + std::fmt::Debug,
+    ES: EdgeSegmentOps,
+> {
+    pub page: &'a ES,
+    pub writer: MP,
+    pub graph_stats: &'a GraphStats,
+    old_estimated_size: usize,
+}
+
+impl<'a, MP: DerefMut<Target = MemEdgeSegment> + std::fmt::Debug, ES: EdgeSegmentOps>
+    EdgeWriter<'a, MP, ES>
+{
+    pub fn new(global_num_edges: &'a GraphStats, page: &'a ES, writer: MP) -> Self {
+        let old_estimated_size = writer.est_size();
+        Self {
+            page,
+            writer,
+            graph_stats: global_num_edges,
+            old_estimated_size,
+        }
+    }
+
+    fn new_local_pos(&self, layer_id: LayerId) -> LocalPOS {
+        let new_pos = LocalPOS(self.page.increment_num_edges());
+        self.increment_layer_num_edges(layer_id);
+        new_pos
+    }
+
+    pub fn add_edge<T: AsTime>(
+        &mut self,
+        t: T,
+        edge_pos: LocalPOS,
+        src: VID,
+        dst: VID,
+        props: impl IntoIterator<Item = (usize, Prop)>,
+        layer_id: LayerId,
+    ) -> LocalPOS {
+        self.graph_stats.update_time(t.t());
+        if self
+            .writer
+            .insert_edge_internal(t, edge_pos, src, dst, layer_id, props)
+            && !self.page.immut_has_edge(edge_pos, layer_id)
+        {
+            // edge is new to this writer and also the immutable part of the segment
+            self.increment_layer_num_edges(layer_id);
+        }
+
+        edge_pos
+    }
+
+    pub fn delete_edge<T: AsTime>(
+        &mut self,
+        t: T,
+        edge_pos: LocalPOS,
+        src: VID,
+        dst: VID,
+        layer_id: LayerId,
+    ) {
+        self.graph_stats.update_time(t.t());
+        if self
+            .writer
+            .delete_edge_internal(t, edge_pos, src, dst, layer_id)
+            && !self.page.immut_has_edge(edge_pos, layer_id)
+        {
+            // edge is new to this writer and also the immutable part of the segment
+            self.increment_layer_num_edges(layer_id);
+        }
+    }
+
+    /// Adds a static edge to the graph.
+    ///
+    /// If `edge_pos` is `None`, a new position is allocated. If `Some`, the provided position
+    /// is used.
+    /// Set `already_counted` to `true` when bulk loading to avoid double-counting statistics.
+    pub fn add_static_edge(
+        &mut self,
+        edge_pos: Option<LocalPOS>,
+        src: impl Into<VID>,
+        dst: impl Into<VID>,
+        already_counted: bool,
+    ) -> LocalPOS {
+        if edge_pos.is_some() && !already_counted {
+            self.page.increment_num_edges();
+            self.increment_layer_num_edges(STATIC_GRAPH_LAYER_ID);
+        }
+
+        let edge_pos = edge_pos.unwrap_or_else(|| self.new_local_pos(STATIC_GRAPH_LAYER_ID));
+        self.writer
+            .insert_static_edge_internal(edge_pos, src, dst, STATIC_GRAPH_LAYER_ID);
+
+        edge_pos
+    }
+
+    pub fn bulk_add_edge<P: AsPropRef>(
+        &mut self,
+        t: EventTime,
+        edge_pos: LocalPOS,
+        src: VID,
+        dst: VID,
+        edge_exists: bool,
+        layer_id: LayerId,
+        c_props: impl IntoIterator<Item = (usize, P)>,
+        t_props: impl IntoIterator<Item = (usize, P)>,
+    ) {
+        if !edge_exists {
+            if self
+                .writer
+                .insert_static_edge_internal(edge_pos, src, dst, STATIC_GRAPH_LAYER_ID)
+            {
+                self.increment_layer_num_edges(STATIC_GRAPH_LAYER_ID);
+            }
+        }
+
+        if self
+            .writer
+            .insert_edge_internal(t, edge_pos, src, dst, layer_id, t_props)
+            && !self.page.immut_has_edge(edge_pos, layer_id)
+        {
+            self.increment_layer_num_edges(layer_id);
+        }
+
+        self.graph_stats.update_time(t.t());
+
+        self.writer
+            .update_const_properties(edge_pos, src, dst, layer_id, c_props);
+    }
+
+    pub fn bulk_delete_edge(
+        &mut self,
+        t: EventTime,
+        edge_pos: LocalPOS,
+        src: VID,
+        dst: VID,
+        exists: bool,
+        layer_id: LayerId,
+    ) {
+        if !exists {
+            if self
+                .writer
+                .insert_static_edge_internal(edge_pos, src, dst, STATIC_GRAPH_LAYER_ID)
+            {
+                self.increment_layer_num_edges(STATIC_GRAPH_LAYER_ID);
+            }
+        }
+
+        self.graph_stats.update_time(t.t());
+        if self
+            .writer
+            .delete_edge_internal(t, edge_pos, src, dst, layer_id)
+            && !self.page.immut_has_edge(edge_pos, layer_id)
+        {
+            self.increment_layer_num_edges(layer_id);
+        }
+    }
+
+    pub fn segment_id(&self) -> usize {
+        self.page.segment_id()
+    }
+
+    fn increment_layer_num_edges(&self, layer_id: LayerId) {
+        self.graph_stats.increment(layer_id);
+    }
+
+    pub fn get_edge(&self, layer_id: LayerId, edge_pos: LocalPOS) -> Option<(VID, VID)> {
+        self.page.get_edge(edge_pos, layer_id, self.writer.deref())
+    }
+
+    pub fn set_lsn(&mut self, lsn: LSN) {
+        self.writer.set_lsn(lsn);
+    }
+
+    pub fn check_metadata<P: AsPropRef>(
+        &self,
+        edge_pos: LocalPOS,
+        layer_id: LayerId,
+        props: &[(usize, P)],
+    ) -> Result<(), StorageError> {
+        self.writer.check_metadata(edge_pos, layer_id, props)
+    }
+
+    pub fn update_c_props<P: AsPropRef>(
+        &mut self,
+        edge_pos: LocalPOS,
+        src: VID,
+        dst: VID,
+        layer_id: LayerId,
+        props: impl IntoIterator<Item = (usize, P)>,
+    ) {
+        let existing_edge = self.page.has_edge(edge_pos, layer_id, self.writer.deref());
+
+        if !existing_edge {
+            self.increment_layer_num_edges(layer_id);
+        }
+        self.writer
+            .update_const_properties(edge_pos, src, dst, layer_id, props);
+    }
+
+    #[inline(always)]
+    pub fn resolve_pos(&self, edge_id: EID) -> Option<LocalPOS> {
+        let (page, pos) = resolve_pos(edge_id, self.writer.max_page_len());
+
+        if page == self.page.segment_id() {
+            Some(pos)
+        } else {
+            None
+        }
+    }
+}
+
+impl<'a, MP: DerefMut<Target = MemEdgeSegment> + std::fmt::Debug, ES: EdgeSegmentOps> Drop
+    for EdgeWriter<'a, MP, ES>
+{
+    fn drop(&mut self) {
+        let delta = self.writer.est_size() - self.old_estimated_size;
+        self.writer.increment_global_memory(delta);
+        if let Err(err) = self.page.notify_write(self.writer.deref_mut()) {
+            eprintln!("Failed to persist {}, err: {}", self.segment_id(), err)
+        }
+    }
+}
diff --git a/db4-storage/src/pages/edge_store.rs b/db4-storage/src/pages/edge_store.rs
new file mode 100644
index 0000000000..9aba63b807
--- /dev/null
+++ b/db4-storage/src/pages/edge_store.rs
@@ -0,0 +1,657 @@
+use super::{edge_page::writer::EdgeWriter, resolve_pos};
+use crate::{
+    LocalPOS,
+    api::edges::{EdgeRefOps, EdgeSegmentOps, LockedESegment},
+    error::StorageError,
+    pages::{
+        SegmentCounts,
+        layer_counter::GraphStats,
+        locked::edges::{LockedEdgePage, WriteLockedEdgePages},
+        row_group_par_iter,
+    },
+    persist::{config::ConfigOps, strategy::PersistenceStrategy},
+    segments::edge::segment::MemEdgeSegment,
+};
+use parking_lot::{RwLock, RwLockWriteGuard};
+use raphtory_api::core::entities::{
+    EID, LayerId, VID,
+    properties::meta::{Meta, STATIC_GRAPH_LAYER_ID},
+};
+use raphtory_core::{
+    entities::{ELID, LayerIds},
+    storage::timeindex::{AsTime, EventTime},
+};
+use rayon::prelude::*;
+use std::{
+    collections::HashMap,
+    ops::Deref,
+    path::{Path, PathBuf},
+    sync::{Arc, LazyLock},
+};
+
+pub static N: LazyLock<usize> = LazyLock::new(|| rayon::current_num_threads());
+
+#[derive(Debug)]
+pub struct EdgeStorageInner<ES, EXT> {
+    segments: boxcar::Vec<Arc<ES>>,
+    layer_counter: Arc<GraphStats>,
+    free_pages: Box<[RwLock<usize>]>,
+    edges_path: Option<PathBuf>,
+    prop_meta: Arc<Meta>,
+    ext: EXT,
+}
+
+#[derive(Debug)]
+pub struct ReadLockedEdgeStorage<ES: EdgeSegmentOps<Extension = EXT>, EXT> {
+    storage: Arc<EdgeStorageInner<ES, EXT>>,
+    locked_pages: Box<[ES::ArcLockedSegment]>,
+}
+
+impl<ES: EdgeSegmentOps<Extension = EXT>, EXT: PersistenceStrategy<ES = ES>>
+    ReadLockedEdgeStorage<ES, EXT>
+{
+    pub fn storage(&self) -> &EdgeStorageInner<ES, EXT> {
+        &self.storage
+    }
+
+    pub fn edge_ref(
+        &self,
+        e_id: impl Into<EID>,
+    ) -> <<ES as EdgeSegmentOps>::ArcLockedSegment as LockedESegment>::EntryRef<'_> {
+        let e_id = e_id.into();
+        let (page_id, pos) = self.storage.resolve_pos(e_id);
+        let locked_page = &self.locked_pages[page_id];
+        locked_page.entry_ref(pos)
+    }
+
+    pub fn iter<'a, 'b: 'a>(
+        &'a self,
+        layer_ids: &'b LayerIds,
+    ) -> impl Iterator<
+        Item = <<ES as EdgeSegmentOps>::ArcLockedSegment as LockedESegment>::EntryRef<'a>,
+    > + 'a {
+        self.locked_pages
+            .iter()
+            .flat_map(move |page| page.edge_iter(layer_ids))
+    }
+
+    pub fn par_iter<'a, 'b: 'a>(
+        &'a self,
+        layer_ids: &'b LayerIds,
+    ) -> impl ParallelIterator<
+        Item = <<ES as EdgeSegmentOps>::ArcLockedSegment as LockedESegment>::EntryRef<'a>,
+    > + 'a {
+        self.locked_pages
+            .par_iter()
+            .flat_map(move |page| page.edge_par_iter(layer_ids))
+    }
+
+    /// Returns an iterator over the segments of the edge store, where each segment is
+    /// a tuple of the segment index and an iterator over the entries in that segment.
+    pub fn segmented_par_iter(
+        &self,
+    ) -> impl ParallelIterator<Item = (usize, impl Iterator<Item = EID>)> + '_ {
+        self.locked_pages
+            .par_iter()
+            .enumerate()
+            .map(move |(segment_id, page)| {
+                (
+                    segment_id,
+                    page.edge_iter(&LayerIds::All).map(|e| e.edge_id()),
+                )
+            })
+    }
+
+    pub fn row_groups_par_iter(
+        &self,
+    ) -> impl IndexedParallelIterator<Item = (usize, impl Iterator<Item = EID> + '_)> {
+        let max_actual_seg_len = self
+            .storage
+            .segments
+            .iter()
+            .map(|(_, seg)| seg.num_edges())
+            .max()
+            .unwrap_or(0);
+        let max_seg_len = self.storage.max_page_len();
+        row_group_par_iter(
+            max_seg_len as usize,
+            self.locked_pages.len(),
+            max_seg_len,
+            max_actual_seg_len,
+        )
+        .map(|(row_group_id, iter)| {
+            (
+                row_group_id,
+                iter.filter(|eid| self.edge_ref(*eid).edge(LayerId(0)).is_some()),
+            )
+        })
+    }
+
+    pub fn segment_counts(&self) -> SegmentCounts<EID> {
+        SegmentCounts::new(
+            self.storage.max_page_len(),
+            self.locked_pages.iter().map(|seg| seg.num_edges()),
+        )
+    }
+}
+
+impl<ES: EdgeSegmentOps<Extension = EXT>, EXT: PersistenceStrategy<ES = ES>>
+    EdgeStorageInner<ES, EXT>
+{
+    pub fn locked(self: &Arc<Self>) -> ReadLockedEdgeStorage<ES, EXT> {
+        let locked_pages = self
+            .segments
+            .iter()
+            .map(|(_, segment)| segment.locked())
+            .collect::<Box<_>>();
+        ReadLockedEdgeStorage {
+            storage: self.clone(),
+            locked_pages,
+        }
+    }
+
+    pub fn edge_meta(&self) -> &Arc<Meta> {
+        &self.prop_meta
+    }
+
+    pub fn stats(&self) -> &Arc<GraphStats> {
+        &self.layer_counter
+    }
+
+    pub fn segments(&self) -> &boxcar::Vec<Arc<ES>> {
+        &self.segments
+    }
+
+    pub fn num_segments(&self) -> usize {
+        self.segments.count()
+    }
+
+    pub fn new_with_meta(edges_path: Option<PathBuf>, edge_meta: Arc<Meta>, ext: EXT) -> Self {
+        let free_pages = (0..(*N)).map(RwLock::new).collect::<Box<[_]>>();
+        let empty = Self {
+            segments: boxcar::Vec::new(),
+            layer_counter: GraphStats::new().into(),
+            free_pages: free_pages.try_into().unwrap(),
+            edges_path,
+            prop_meta: edge_meta,
+            ext,
+        };
+        let layer_mapper = empty.edge_meta().layer_meta();
+        let prop_mapper = empty.edge_meta().temporal_prop_mapper();
+        let metadata_mapper = empty.edge_meta().metadata_mapper();
+
+        if layer_mapper.num_fields() > 0
+            || prop_mapper.num_fields() > 0
+            || metadata_mapper.num_fields() > 0
+        {
+            let segment = empty.get_or_create_segment(STATIC_GRAPH_LAYER_ID.0);
+            let mut head = segment.head_mut();
+
+            for layer in layer_mapper.ids() {
+                head.get_or_create_layer(LayerId(layer));
+            }
+
+            if prop_mapper.num_fields() > 0 {
+                head.get_or_create_layer(LayerId(0))
+                    .properties_mut()
+                    .set_has_properties()
+            }
+
+            segment.set_dirty(true);
+        }
+        empty
+    }
+
+    pub fn new(edges_path: Option<PathBuf>, ext: EXT) -> Self {
+        Self::new_with_meta(edges_path, Meta::new_for_edges().into(), ext)
+    }
+
+    pub fn pages(&self) -> &boxcar::Vec<Arc<ES>> {
+        &self.segments
+    }
+
+    pub fn edges_path(&self) -> Option<&Path> {
+        self.edges_path.as_ref().map(|path| path.as_path())
+    }
+
+    pub fn earliest(&self) -> Option<EventTime> {
+        Iterator::min(self.segments.iter().filter_map(|(_, page)| page.earliest()))
+        // see : https://github.com/rust-lang/rust-analyzer/issues/10653
+    }
+
+    pub fn latest(&self) -> Option<EventTime> {
+        Iterator::max(self.segments.iter().filter_map(|(_, page)| page.latest()))
+    }
+
+    pub fn t_len(&self) -> usize {
+        self.segments.iter().map(|(_, page)| page.t_len()).sum()
+    }
+
+    pub fn prop_meta(&self) -> &Arc<Meta> {
+        &self.prop_meta
+    }
+
+    #[inline(always)]
+    pub fn resolve_pos(&self, e_id: EID) -> (usize, LocalPOS) {
+        resolve_pos(e_id, self.max_page_len())
+    }
+
+    pub fn load(edges_path: impl AsRef<Path>, ext: EXT) -> Result<Self, StorageError> {
+        let edges_path = edges_path.as_ref();
+        let max_page_len = ext.config().max_edge_page_len();
+
+        let meta = Arc::new(Meta::new_for_edges());
+
+        if !edges_path.exists() {
+            return Ok(Self::new(Some(edges_path.to_path_buf()), ext.clone()));
+        }
+
+        let mut pages = std::fs::read_dir(edges_path)?
+            .par_bridge()
+            .filter(|entry| {
+                entry
+                    .as_ref()
+                    .ok()
+                    .and_then(|entry| entry.file_type().ok().map(|ft| ft.is_dir()))
+                    .unwrap_or_default()
+            })
+            .filter_map(|entry| {
+                let entry = entry.ok()?;
+                let page_id = entry
+                    .path()
+                    .file_stem()
+                    .and_then(|name| name.to_str().and_then(|name| name.parse::<usize>().ok()))?;
+                let page = ES::load(page_id, max_page_len, meta.clone(), edges_path, ext.clone())
+                    .map(|page| (page_id, page));
+
+                Some(page)
+            })
+            .collect::<Result<HashMap<_, _>, _>>()?;
+
+        if pages.is_empty() {
+            return Err(StorageError::EmptyGraphDir(edges_path.to_path_buf()));
+        }
+
+        let max_page = Iterator::max(pages.keys().copied()).unwrap();
+
+        let pages: boxcar::Vec<Arc<ES>> = (0..=max_page)
+            .map(|page_id| {
+                let np = pages.remove(&page_id).unwrap_or_else(|| {
+                    ES::new(
+                        page_id,
+                        meta.clone(),
+                        Some(edges_path.to_path_buf()),
+                        ext.clone(),
+                    )
+                });
+                Arc::new(np)
+            })
+            .collect::<boxcar::Vec<_>>();
+
+        let first_page = pages.iter().next().unwrap().1;
+        let first_p_id = first_page.segment_id();
+
+        if first_p_id != 0 {
+            return Err(StorageError::GenericFailure(format!(
+                "First page id is not 0 in {edges_path:?}"
+            )));
+        }
+
+        let mut free_pages = pages
+            .iter()
+            .filter_map(|(_, page)| {
+                let len = page.num_edges();
+                if len < max_page_len {
+                    Some(RwLock::new(page.segment_id()))
+                } else {
+                    None
+                }
+            })
+            .collect::<Vec<_>>();
+
+        let mut next_free_page = free_pages
+            .last()
+            .map(|page| *(page.read()))
+            .map(|last| last + 1)
+            .unwrap_or_else(|| pages.count());
+
+        free_pages.resize_with(*N, || {
+            let lock = RwLock::new(next_free_page);
+            next_free_page += 1;
+            lock
+        });
+
+        let mut layer_counts = vec![];
+
+        for (_, page) in pages.iter() {
+            for layer_id in 0..page.num_layers() {
+                let count = page.layer_count(LayerId(layer_id)) as usize;
+                if layer_counts.len() <= layer_id {
+                    layer_counts.resize(layer_id + 1, 0);
+                }
+                layer_counts[layer_id] += count;
+            }
+        }
+
+        let earliest = pages
+            .iter()
+            .filter_map(|(_, page)| page.earliest().filter(|t| t.t() != i64::MAX))
+            .map(|t| t.t())
+            .min()
+            .unwrap_or(i64::MAX);
+
+        let latest = pages
+            .iter()
+            .filter_map(|(_, page)| page.latest().filter(|t| t.t() != i64::MIN))
+            .map(|t| t.t())
+            .max()
+            .unwrap_or(i64::MIN);
+
+        let stats = GraphStats::load(layer_counts, earliest, latest);
+
+        Ok(Self {
+            segments: pages,
+            edges_path: Some(edges_path.to_path_buf()),
+            layer_counter: stats.into(),
+            free_pages: free_pages.try_into().unwrap(),
+            prop_meta: meta,
+            ext,
+        })
+    }
+
+    pub fn grow(&self, size: usize) {
+        self.get_or_create_segment(size - 1);
+    }
+
+    pub fn push_new_page(&self) -> usize {
+        let segment_id = self.segments.push_with(|segment_id| {
+            Arc::new(ES::new(
+                segment_id,
+                self.prop_meta.clone(),
+                self.edges_path.clone(),
+                self.ext.clone(),
+            ))
+        });
+
+        while self.segments.get(segment_id).is_none() {
+            // wait
+        }
+
+        segment_id
+    }
+
+    pub fn increment_edge_segment_count(&self, eid: EID) {
+        let (segment_id, _) = resolve_pos(eid, self.max_page_len());
+        let segment = self.get_or_create_segment(segment_id);
+        segment.increment_num_edges();
+    }
+
+    pub fn get_or_create_segment(&self, segment_id: usize) -> &Arc<ES> {
+        if let Some(segment) = self.segments.get(segment_id) {
+            return segment;
+        }
+
+        let count = self.segments.count();
+
+        if count > segment_id {
+            // Something has allocated the segment, wait for it to be added.
+            loop {
+                if let Some(segment) = self.segments.get(segment_id) {
+                    return segment;
+                } else {
+                    // wait for the segment to be created
+                    std::thread::yield_now();
+                }
+            }
+        } else {
+            // We need to create the segment.
+            self.segments.reserve(segment_id + 1 - count);
+
+            loop {
+                let new_segment_id = self.segments.push_with(|segment_id| {
+                    Arc::new(ES::new(
+                        segment_id,
+                        self.prop_meta.clone(),
+                        self.edges_path.clone(),
+                        self.ext.clone(),
+                    ))
+                });
+
+                if new_segment_id >= segment_id {
+                    loop {
+                        if let Some(segment) = self.segments.get(segment_id) {
+                            return segment;
+                        } else {
+                            // Wait for the segment to be created.
+                            std::thread::yield_now();
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    #[inline(always)]
+    pub fn max_page_len(&self) -> u32 {
+        self.ext.config().max_edge_page_len()
+    }
+
+    pub fn write_locked<'a>(&'a self) -> WriteLockedEdgePages<'a, ES> {
+        WriteLockedEdgePages::new(
+            self.segments
+                .iter()
+                .map(|(page_id, page)| {
+                    LockedEdgePage::new(
+                        page_id,
+                        self.max_page_len(),
+                        page.as_ref(),
+                        &self.layer_counter,
+                        page.head_mut(),
+                    )
+                })
+                .collect(),
+        )
+    }
+
+    /// Retrieve the segment for an edge given its EID
+    pub fn get_edge_segment(&self, eid: EID) -> Option<&Arc<ES>> {
+        let (segment_id, _) = resolve_pos(eid, self.max_page_len());
+        self.segments.get(segment_id)
+    }
+
+    pub fn get_edge(&self, e_id: ELID) -> Option<(VID, VID)> {
+        let layer = e_id.layer();
+        let e_id = e_id.edge;
+        let (segment_id, local_edge) = resolve_pos(e_id, self.max_page_len());
+        let segment = self.segments.get(segment_id)?;
+        segment.get_edge(local_edge, layer, segment.head())
+    }
+
+    pub fn edge(&self, e_id: impl Into<EID>) -> ES::Entry<'_> {
+        let e_id = e_id.into();
+        let (segment_id, local_edge) = resolve_pos(e_id, self.max_page_len());
+        let segment = self.segments.get(segment_id).unwrap_or_else(|| {
+            panic!(
+                "{e_id:?} Not found in seg: {segment_id}, pos: {local_edge:?}, num_segments: {}",
+                self.segments.count()
+            )
+        });
+        segment.entry(local_edge)
+    }
+
+    pub fn num_edges(&self) -> usize {
+        self.layer_counter.get(LayerId(0))
+    }
+
+    pub fn num_edges_layer(&self, layer_id: LayerId) -> usize {
+        self.layer_counter.get(layer_id)
+    }
+
+    pub fn get_writer<'a>(
+        &'a self,
+        e_id: EID,
+    ) -> EdgeWriter<'a, RwLockWriteGuard<'a, MemEdgeSegment>, ES> {
+        let (chunk, _) = resolve_pos(e_id, self.max_page_len());
+        let page = self.get_or_create_segment(chunk);
+        EdgeWriter::new(&self.layer_counter, page, page.head_mut())
+    }
+
+    pub fn try_get_writer<'a>(
+        &'a self,
+        e_id: EID,
+    ) -> Result<EdgeWriter<'a, RwLockWriteGuard<'a, MemEdgeSegment>, ES>, StorageError> {
+        let (segment_id, _) = resolve_pos(e_id, self.max_page_len());
+        let page = self.get_or_create_segment(segment_id);
+        let writer = page.head_mut();
+        Ok(EdgeWriter::new(&self.layer_counter, page, writer))
+    }
+
+    pub fn get_free_writer<'a>(
+        &'a self,
+    ) -> EdgeWriter<'a, RwLockWriteGuard<'a, MemEdgeSegment>, ES> {
+        // optimistic first try to get a free page 3 times
+        let num_edges = self.num_edges();
+        let slot_idx = num_edges % *N;
+        let maybe_free_page = self.free_pages[slot_idx..]
+            .iter()
+            .cycle()
+            .take(3)
+            .filter_map(|lock| lock.try_read())
+            .filter_map(|page_id| {
+                let page = self.segments.get(*page_id)?;
+                let guard = page.try_head_mut()?;
+                if page.num_edges() < self.max_page_len() {
+                    Some((page, guard))
+                } else {
+                    None
+                }
+            })
+            .next();
+
+        if let Some((edge_page, writer)) = maybe_free_page {
+            EdgeWriter::new(&self.layer_counter, edge_page, writer)
+        } else {
+            // not lucky, go wait on your slot
+            loop {
+                let mut slot = self.free_pages[slot_idx].write();
+                match self.segments.get(*slot).map(|page| (page, page.head_mut())) {
+                    Some((edge_page, writer)) if edge_page.num_edges() < self.max_page_len() => {
+                        return EdgeWriter::new(&self.layer_counter, edge_page, writer);
+                    }
+                    _ => {
+                        *slot = self.push_new_page();
+                    }
+                }
+            }
+        }
+    }
+
+    pub fn reserve_new_eid(&self, row: usize) -> EID {
+        let (segment_id, local_pos) = self.reserve_free_pos(row);
+        local_pos.as_eid(segment_id, self.max_page_len())
+    }
+
+    pub fn reserve_free_pos(&self, row: usize) -> (usize, LocalPOS) {
+        let slot_idx = row % *N;
+        let maybe_free_page = {
+            let lock_slot = self.free_pages[slot_idx].read_recursive();
+            let page_id = *lock_slot;
+            let page = self.segments.get(page_id);
+            page.and_then(|page| {
+                self.reserve_page_row(page)
+                    .map(|pos| (page.segment_id(), LocalPOS(pos)))
+            })
+        };
+
+        if let Some(reserved_pos) = maybe_free_page {
+            reserved_pos
+        } else {
+            // not lucky, go wait on your slot
+            let mut slot = self.free_pages[slot_idx].write();
+            loop {
+                if let Some(page) = self.segments.get(*slot)
+                    && let Some(pos) = self.reserve_page_row(page)
+                {
+                    return (page.segment_id(), LocalPOS(pos));
+                }
+                *slot = self.push_new_page();
+            }
+        }
+    }
+
+    fn reserve_page_row(&self, page: &Arc<ES>) -> Option<u32> {
+        // TODO: if this becomes a hotspot, we can switch to a fetch_add followed by a fetch_min
+        // this means when we read the counter we need to clamp it to max_page_len so the iterators don't break
+        page.edges_counter()
+            .fetch_update(
+                std::sync::atomic::Ordering::Relaxed,
+                std::sync::atomic::Ordering::Relaxed,
+                |current| {
+                    if current < self.max_page_len() {
+                        Some(current + 1)
+                    } else {
+                        None
+                    }
+                },
+            )
+            .ok()
+    }
+
+    pub fn par_iter_segments(&self) -> impl ParallelIterator<Item = &ES> {
+        (0..self.segments.count())
+            .into_par_iter()
+            .filter_map(|idx| self.segments.get(idx).map(|seg| seg.deref()))
+    }
+
+    pub fn par_iter(&self, layer: LayerId) -> impl ParallelIterator<Item = ES::Entry<'_>> + '_ {
+        self.par_iter_segments().flat_map(move |page| {
+            (0..page.num_edges())
+                .into_par_iter()
+                .map(LocalPOS)
+                .filter_map(move |local_edge| {
+                    page.layer_entry(local_edge, layer, Some(page.head()))
+                })
+        })
+    }
+
+    pub fn iter(&self, layer: LayerId) -> impl Iterator<Item = ES::Entry<'_>> + '_ {
+        (0..self.segments.count())
+            .filter_map(move |page_id| self.segments.get(page_id))
+            .flat_map(move |page| {
+                (0..page.num_edges()).filter_map(move |local_edge| {
+                    page.layer_entry(LocalPOS(local_edge), layer, Some(page.head()))
+                })
+            })
+    }
+
+    /// Returns an iterator over the segments of the edge store, where each segment is
+    /// a tuple of the segment index and an iterator over the entries in that segment.
+    pub fn segmented_par_iter(
+        &self,
+    ) -> impl ParallelIterator<Item = (usize, impl Iterator<Item = EID>)> + '_ {
+        let max_page_len = self.max_page_len();
+        (0..self.segments.count())
+            .into_par_iter()
+            .filter_map(move |segment_id| {
+                self.segments.get(segment_id).map(move |page| {
+                    (
+                        segment_id,
+                        (0..page.num_edges()).map(move |edge_pos| {
+                            LocalPOS(edge_pos).as_eid(segment_id, max_page_len)
+                        }),
+                    )
+                })
+            })
+    }
+
+    pub fn segment_counts(&self) -> SegmentCounts<EID> {
+        SegmentCounts::new(
+            self.max_page_len(),
+            self.pages().iter().map(|(_, seg)| seg.num_edges()),
+        )
+    }
+
+    pub fn flush(&self) -> Result<(), StorageError> {
+        self.par_iter_segments().try_for_each(|seg| seg.flush())
+    }
+}
diff --git a/db4-storage/src/pages/graph_prop_page/mod.rs b/db4-storage/src/pages/graph_prop_page/mod.rs
new file mode 100644
index 0000000000..d3baa81782
--- /dev/null
+++ b/db4-storage/src/pages/graph_prop_page/mod.rs
@@ -0,0 +1 @@
+pub mod writer;
diff --git a/db4-storage/src/pages/graph_prop_page/writer.rs b/db4-storage/src/pages/graph_prop_page/writer.rs
new file mode 100644
index 0000000000..a6eb8981bf
--- /dev/null
+++ b/db4-storage/src/pages/graph_prop_page/writer.rs
@@ -0,0 +1,60 @@
+use crate::{
+    api::graph_props::GraphPropSegmentOps, error::StorageError,
+    segments::graph_prop::segment::MemGraphPropSegment, wal::LSN,
+};
+use parking_lot::RwLockWriteGuard;
+use raphtory_api::core::entities::properties::prop::AsPropRef;
+use raphtory_core::storage::timeindex::AsTime;
+
+/// Provides mutable access to a graph segment. Holds an exclusive write lock
+/// on the in-memory segment for the duration of its lifetime.
+pub struct GraphPropWriter<'a, GS: GraphPropSegmentOps> {
+    pub mem_segment: RwLockWriteGuard<'a, MemGraphPropSegment>,
+    pub graph_props: &'a GS,
+}
+
+impl<'a, GS: GraphPropSegmentOps> GraphPropWriter<'a, GS> {
+    pub fn new(
+        graph_props: &'a GS,
+        mem_segment: RwLockWriteGuard<'a, MemGraphPropSegment>,
+    ) -> Self {
+        Self {
+            mem_segment,
+            graph_props,
+        }
+    }
+
+    pub fn add_properties<T: AsTime, P: AsPropRef>(
+        &mut self,
+        t: T,
+        props: impl IntoIterator<Item = (usize, P)>,
+    ) {
+        let add = self.mem_segment.add_properties(t, props);
+
+        self.graph_props.increment_est_size(add);
+        self.graph_props.set_dirty(true);
+    }
+
+    pub fn update_metadata<P: AsPropRef>(&mut self, props: impl IntoIterator<Item = (usize, P)>) {
+        let add = self.mem_segment.update_metadata(props);
+
+        self.graph_props.increment_est_size(add);
+        self.graph_props.set_dirty(true);
+    }
+
+    pub fn check_metadata<P: AsPropRef>(&self, props: &[(usize, P)]) -> Result<(), StorageError> {
+        self.mem_segment.check_metadata(props)
+    }
+
+    pub fn set_lsn(&mut self, lsn: LSN) {
+        self.mem_segment.set_lsn(lsn);
+    }
+}
+
+impl<GS: GraphPropSegmentOps> Drop for GraphPropWriter<'_, GS> {
+    fn drop(&mut self) {
+        self.graph_props
+            .notify_write(&mut self.mem_segment)
+            .expect("Failed to persist node page");
+    }
+}
diff --git a/db4-storage/src/pages/graph_prop_store.rs b/db4-storage/src/pages/graph_prop_store.rs
new file mode 100644
index 0000000000..c91f436dd5
--- /dev/null
+++ b/db4-storage/src/pages/graph_prop_store.rs
@@ -0,0 +1,89 @@
+use crate::{
+    api::graph_props::GraphPropSegmentOps,
+    error::StorageError,
+    pages::{
+        graph_prop_page::writer::GraphPropWriter,
+        locked::graph_props::{LockedGraphPropPage, WriteLockedGraphPropPages},
+    },
+    persist::strategy::PersistenceStrategy,
+};
+use raphtory_api::core::entities::properties::meta::Meta;
+use std::{
+    path::{Path, PathBuf},
+    sync::Arc,
+};
+
+/// Backing store for graph temporal properties and graph metadata.
+#[derive(Debug)]
+pub struct GraphPropStorageInner<GS, EXT> {
+    /// The graph props segment that contains all graph properties and graph metadata.
+    /// Unlike node and edge segments, which are split into multiple segments,
+    /// there is always only one graph props segment.
+    page: Arc<GS>,
+
+    /// Stores graph prop metadata (prop name -> prop id mappings).
+    meta: Arc<Meta>,
+
+    path: Option<PathBuf>,
+
+    ext: EXT,
+}
+
+impl<GS: GraphPropSegmentOps<Extension = EXT>, EXT: PersistenceStrategy>
+    GraphPropStorageInner<GS, EXT>
+{
+    pub fn new_with_meta(path: Option<&Path>, meta: Arc<Meta>, ext: EXT) -> Self {
+        let page = Arc::new(GS::new(meta.clone(), path, ext.clone()));
+
+        Self {
+            page,
+            path: path.map(|p| p.to_path_buf()),
+            meta,
+            ext,
+        }
+    }
+
+    pub fn load(path: impl AsRef<Path>, ext: EXT) -> Result<Self, StorageError> {
+        let graph_props_meta = Arc::new(Meta::new_for_graph_props());
+
+        Ok(Self {
+            page: Arc::new(GS::load(
+                graph_props_meta.clone(),
+                path.as_ref(),
+                ext.clone(),
+            )?),
+            path: Some(path.as_ref().to_path_buf()),
+            meta: graph_props_meta,
+            ext,
+        })
+    }
+
+    pub fn meta(&self) -> &Arc<Meta> {
+        &self.meta
+    }
+
+    pub fn graph_entry(&self) -> GS::Entry<'_> {
+        self.page.entry()
+    }
+
+    pub fn segment(&self) -> &Arc<GS> {
+        &self.page
+    }
+
+    pub fn writer(&self) -> GraphPropWriter<'_, GS> {
+        let head = self.page.head_mut();
+        let graph_props = &self.page;
+        GraphPropWriter::new(graph_props, head)
+    }
+
+    pub fn write_locked<'a>(&'a self) -> WriteLockedGraphPropPages<'a, GS> {
+        WriteLockedGraphPropPages::new(LockedGraphPropPage::new(
+            self.page.as_ref(),
+            self.page.head_mut(),
+        ))
+    }
+
+    pub fn flush(&self) -> Result<(), StorageError> {
+        self.page.flush()
+    }
+}
diff --git a/db4-storage/src/pages/layer_counter.rs b/db4-storage/src/pages/layer_counter.rs
new file mode 100644
index 0000000000..e94f8567b7
--- /dev/null
+++ b/db4-storage/src/pages/layer_counter.rs
@@ -0,0 +1,119 @@
+use raphtory_api::core::entities::LayerId;
+use raphtory_core::entities::graph::timer::{MaxCounter, MinCounter, TimeCounterTrait};
+use std::sync::atomic::AtomicUsize;
+
+#[derive(Debug)]
+pub struct GraphStats {
+    layers: boxcar::Vec<AtomicUsize>,
+    earliest: MinCounter,
+    latest: MaxCounter,
+}
+
+impl<I: IntoIterator<Item = usize>> From<I> for GraphStats {
+    fn from(iter: I) -> Self {
+        let layers = iter.into_iter().map(AtomicUsize::new).collect();
+        Self {
+            layers,
+            earliest: MinCounter::new(),
+            latest: MaxCounter::new(),
+        }
+    }
+}
+
+impl Default for GraphStats {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl GraphStats {
+    pub fn new() -> Self {
+        let layers = boxcar::Vec::new();
+        layers.push_with(|_| Default::default());
+        Self {
+            layers,
+            earliest: MinCounter::new(),
+            latest: MaxCounter::new(),
+        }
+    }
+
+    pub fn load(counts: impl IntoIterator<Item = usize>, earliest: i64, latest: i64) -> Self {
+        let layers = counts.into_iter().map(AtomicUsize::new).collect();
+        let earliest = MinCounter::from(earliest);
+        let latest = MaxCounter::from(latest);
+        Self {
+            layers,
+            earliest,
+            latest,
+        }
+    }
+
+    pub fn len(&self) -> usize {
+        self.layers.count()
+    }
+
+    #[must_use]
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    pub fn update_time(&self, t: i64) {
+        self.earliest.update(t);
+        self.latest.update(t);
+    }
+
+    pub fn earliest(&self) -> i64 {
+        self.earliest.get()
+    }
+
+    pub fn latest(&self) -> i64 {
+        self.latest.get()
+    }
+
+    pub fn increment(&self, layer_id: LayerId) -> usize {
+        let counter = self.get_or_create_layer(layer_id);
+        counter.fetch_add(1, std::sync::atomic::Ordering::Release)
+    }
+
+    pub fn get(&self, layer_id: LayerId) -> usize {
+        let counter = self.get_or_create_layer(layer_id);
+        counter.load(std::sync::atomic::Ordering::Acquire)
+    }
+
+    pub fn get_counter(&self, layer_id: LayerId) -> &AtomicUsize {
+        self.get_or_create_layer(layer_id)
+    }
+
+    fn get_or_create_layer(&self, layer_id: LayerId) -> &AtomicUsize {
+        let layer_id = layer_id.0;
+        if let Some(counter) = self.layers.get(layer_id) {
+            return counter;
+        }
+
+        if self.layers.count() > layer_id {
+            // something has allocated the layer, wait for it to be added
+            loop {
+                if let Some(counter) = self.layers.get(layer_id) {
+                    return counter;
+                } else {
+                    // wait for the layer to be created
+                    std::thread::yield_now();
+                }
+            }
+        } else {
+            loop {
+                let new_layer_id = self.layers.push_with(|_| Default::default());
+                if new_layer_id >= layer_id {
+                    loop {
+                        if let Some(counter) = self.layers.get(layer_id) {
+                            return counter;
+                        } else {
+                            // wait for the layer to be created
+                            std::thread::yield_now();
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/db4-storage/src/pages/locked/edges.rs b/db4-storage/src/pages/locked/edges.rs
new file mode 100644
index 0000000000..b365df5ce1
--- /dev/null
+++ b/db4-storage/src/pages/locked/edges.rs
@@ -0,0 +1,141 @@
+use std::ops::{Deref, DerefMut};
+
+use crate::{
+    LocalPOS,
+    api::edges::EdgeSegmentOps,
+    error::StorageError,
+    pages::{edge_page::writer::EdgeWriter, layer_counter::GraphStats, resolve_pos},
+    persist::strategy::PersistenceStrategy,
+    segments::edge::segment::MemEdgeSegment,
+};
+use parking_lot::RwLockWriteGuard;
+use raphtory_api::core::entities::LayerId;
+use raphtory_core::entities::{EID, ELID};
+use rayon::prelude::*;
+
+#[derive(Debug)]
+pub struct LockedEdgePage<'a, ES> {
+    page_id: usize,
+    max_page_len: u32,
+    page: &'a ES,
+    num_edges: &'a GraphStats,
+    lock: RwLockWriteGuard<'a, MemEdgeSegment>,
+}
+
+impl<'a, ES: EdgeSegmentOps> LockedEdgePage<'a, ES> {
+    pub fn new(
+        page_id: usize,
+        max_page_len: u32,
+        page: &'a ES,
+        num_edges: &'a GraphStats,
+        lock: RwLockWriteGuard<'a, MemEdgeSegment>,
+    ) -> Self {
+        Self {
+            page_id,
+            max_page_len,
+            page,
+            num_edges,
+            lock,
+        }
+    }
+
+    #[inline(always)]
+    pub fn writer(&mut self) -> EdgeWriter<'_, &mut MemEdgeSegment, ES> {
+        EdgeWriter::new(self.num_edges, self.page, self.lock.deref_mut())
+    }
+
+    #[inline(always)]
+    pub fn page_id(&self) -> usize {
+        self.page_id
+    }
+
+    #[inline(always)]
+    pub fn resolve_pos(&self, edge_id: EID) -> Option<LocalPOS> {
+        let (page, pos) = resolve_pos(edge_id, self.max_page_len);
+
+        if page == self.page_id {
+            Some(pos)
+        } else {
+            None
+        }
+    }
+
+    pub fn ensure_layer(&mut self, layer_id: LayerId) {
+        self.lock.get_or_create_layer(layer_id);
+    }
+
+    pub fn page(&self) -> &ES {
+        &self.page
+    }
+}
+#[derive(Debug)]
+pub struct WriteLockedEdgePages<'a, ES> {
+    writers: Vec<LockedEdgePage<'a, ES>>,
+}
+
+impl<ES> Default for WriteLockedEdgePages<'_, ES> {
+    fn default() -> Self {
+        Self {
+            writers: Vec::new(),
+        }
+    }
+}
+
+impl<'a, EXT: PersistenceStrategy<ES = ES>, ES: EdgeSegmentOps<Extension = EXT>>
+    WriteLockedEdgePages<'a, ES>
+{
+    pub fn new(writers: Vec<LockedEdgePage<'a, ES>>) -> Self {
+        Self { writers }
+    }
+
+    #[inline]
+    pub fn get_mut(&mut self, segment_id: usize) -> Option<&mut LockedEdgePage<'a, ES>> {
+        self.writers.get_mut(segment_id)
+    }
+
+    pub fn par_iter_mut(&mut self) -> rayon::slice::IterMut<'_, LockedEdgePage<'a, ES>> {
+        self.writers.par_iter_mut()
+    }
+
+    pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, LockedEdgePage<'a, ES>> {
+        self.writers.iter_mut()
+    }
+
+    pub fn into_par_iter(self) -> impl ParallelIterator<Item = LockedEdgePage<'a, ES>> + 'a {
+        self.writers.into_par_iter()
+    }
+
+    pub fn ensure_layer(&mut self, layer_id: LayerId) {
+        for writer in &mut self.writers {
+            writer.ensure_layer(layer_id);
+        }
+    }
+
+    pub fn exists(&self, elid: ELID) -> bool {
+        let max_page_len = if !self.writers.is_empty() {
+            self.writers[0].max_page_len
+        } else {
+            return false;
+        };
+        let (page_id, pos) = resolve_pos(elid.edge, max_page_len);
+        self.writers.get(page_id).is_some_and(|page| {
+            let locked_head = page.lock.deref();
+            page.page.has_edge(pos, elid.layer(), locked_head)
+        })
+    }
+
+    pub fn vacuum(&mut self) -> Result<(), StorageError> {
+        for LockedEdgePage { page, lock, .. } in &mut self.writers {
+            page.vacuum(lock.deref_mut())?;
+        }
+        Ok(())
+    }
+
+    pub fn len(&self) -> usize {
+        self.writers.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.writers.is_empty()
+    }
+}
diff --git a/db4-storage/src/pages/locked/graph_props.rs b/db4-storage/src/pages/locked/graph_props.rs
new file mode 100644
index 0000000000..319835ab22
--- /dev/null
+++ b/db4-storage/src/pages/locked/graph_props.rs
@@ -0,0 +1,73 @@
+use crate::{
+    api::graph_props::GraphPropSegmentOps, segments::graph_prop::segment::MemGraphPropSegment,
+    wal::LSN,
+};
+use parking_lot::RwLockWriteGuard;
+use raphtory_api::core::entities::properties::prop::Prop;
+use raphtory_core::storage::timeindex::AsTime;
+
+pub struct LockedGraphPropPage<'a, GS: GraphPropSegmentOps> {
+    page: &'a GS,
+    lock: RwLockWriteGuard<'a, MemGraphPropSegment>,
+}
+
+impl<'a, GS: GraphPropSegmentOps> LockedGraphPropPage<'a, GS> {
+    pub fn new(page: &'a GS, lock: RwLockWriteGuard<'a, MemGraphPropSegment>) -> Self {
+        Self { page, lock }
+    }
+
+    pub fn segment(&self) -> &GS {
+        self.page
+    }
+
+    /// Add temporal properties to the graph
+    pub fn add_properties<T: AsTime>(
+        &mut self,
+        t: T,
+        props: impl IntoIterator<Item = (usize, Prop)>,
+    ) {
+        let add = self.lock.add_properties(t, props);
+
+        self.page.increment_est_size(add);
+        self.page.set_dirty(true);
+    }
+
+    /// Add metadata (constant properties) to the graph
+    pub fn add_metadata(&mut self, props: impl IntoIterator<Item = (usize, Prop)>) {
+        self.update_metadata(props);
+    }
+
+    /// Update metadata (constant properties) on the graph
+    pub fn update_metadata(&mut self, props: impl IntoIterator<Item = (usize, Prop)>) {
+        let add = self.lock.update_metadata(props);
+
+        self.page.increment_est_size(add);
+        self.page.set_dirty(true);
+    }
+
+    pub fn set_lsn(&mut self, lsn: LSN) {
+        self.lock.set_lsn(lsn);
+    }
+}
+
+impl<GS: GraphPropSegmentOps> Drop for LockedGraphPropPage<'_, GS> {
+    fn drop(&mut self) {
+        self.page
+            .notify_write(&mut self.lock)
+            .expect("Failed to persist graph props page");
+    }
+}
+
+pub struct WriteLockedGraphPropPages<'a, GS: GraphPropSegmentOps> {
+    writer: LockedGraphPropPage<'a, GS>,
+}
+
+impl<'a, GS: GraphPropSegmentOps> WriteLockedGraphPropPages<'a, GS> {
+    pub fn new(writer: LockedGraphPropPage<'a, GS>) -> Self {
+        Self { writer }
+    }
+
+    pub fn writer(&mut self) -> &mut LockedGraphPropPage<'a, GS> {
+        &mut self.writer
+    }
+}
diff --git a/db4-storage/src/pages/locked/mod.rs b/db4-storage/src/pages/locked/mod.rs
new file mode 100644
index 0000000000..de88345004
--- /dev/null
+++ b/db4-storage/src/pages/locked/mod.rs
@@ -0,0 +1,3 @@
+pub mod edges;
+pub mod graph_props;
+pub mod nodes;
diff --git a/db4-storage/src/pages/locked/nodes.rs b/db4-storage/src/pages/locked/nodes.rs
new file mode 100644
index 0000000000..5f46be2042
--- /dev/null
+++ b/db4-storage/src/pages/locked/nodes.rs
@@ -0,0 +1,132 @@
+use crate::{
+    LocalPOS,
+    api::nodes::NodeSegmentOps,
+    error::StorageError,
+    pages::{layer_counter::GraphStats, node_page::writer::NodeWriter, resolve_pos},
+    persist::strategy::PersistenceStrategy,
+    segments::node::segment::MemNodeSegment,
+};
+use parking_lot::RwLockWriteGuard;
+use raphtory_api::core::entities::LayerId;
+use raphtory_core::entities::VID;
+use rayon::prelude::*;
+use std::ops::DerefMut;
+
+#[derive(Debug)]
+pub struct LockedNodePage<'a, NS> {
+    segment_id: usize,
+    max_page_len: u32,
+    layer_counter: &'a GraphStats,
+    page: &'a NS,
+    lock: RwLockWriteGuard<'a, MemNodeSegment>,
+}
+
+impl<'a, NS: NodeSegmentOps> LockedNodePage<'a, NS> {
+    pub fn new(
+        segment_id: usize,
+        layer_counter: &'a GraphStats,
+        max_page_len: u32,
+        page: &'a NS,
+        lock: RwLockWriteGuard<'a, MemNodeSegment>,
+    ) -> Self {
+        Self {
+            segment_id,
+            layer_counter,
+            max_page_len,
+            page,
+            lock,
+        }
+    }
+
+    pub fn segment(&self) -> &NS {
+        self.page
+    }
+
+    #[inline(always)]
+    pub fn writer(&mut self) -> NodeWriter<'_, &mut MemNodeSegment, NS> {
+        NodeWriter::new(self.page, self.layer_counter, self.lock.deref_mut())
+    }
+
+    pub fn head(&mut self) -> &mut MemNodeSegment {
+        self.lock.deref_mut()
+    }
+
+    pub fn vacuum(&mut self) {
+        let _ = self.page.vacuum(self.lock.deref_mut());
+    }
+
+    #[inline(always)]
+    pub fn segment_id(&self) -> usize {
+        self.segment_id
+    }
+
+    #[inline(always)]
+    pub fn resolve_pos(&self, node_id: VID) -> Option<LocalPOS> {
+        let (page, pos) = resolve_pos(node_id, self.max_page_len);
+
+        if page == self.segment_id {
+            Some(pos)
+        } else {
+            None
+        }
+    }
+
+    pub fn ensure_layer(&mut self, layer_id: LayerId) {
+        self.lock.get_or_create_layer(layer_id);
+        self.layer_counter.get(layer_id);
+    }
+}
+
+pub struct WriteLockedNodePages<'a, NS> {
+    writers: Vec<LockedNodePage<'a, NS>>,
+}
+
+impl<NS> Default for WriteLockedNodePages<'_, NS> {
+    fn default() -> Self {
+        Self {
+            writers: Vec::new(),
+        }
+    }
+}
+
+impl<'a, EXT: PersistenceStrategy<NS = NS>, NS: NodeSegmentOps<Extension = EXT>>
+    WriteLockedNodePages<'a, NS>
+{
+    pub fn new(writers: Vec<LockedNodePage<'a, NS>>) -> Self {
+        Self { writers }
+    }
+
+    pub fn len(&self) -> usize {
+        self.writers.len()
+    }
+
+    #[inline]
+    pub fn get_mut(&mut self, segment_id: usize) -> Option<&mut LockedNodePage<'a, NS>> {
+        self.writers.get_mut(segment_id)
+    }
+
+    pub fn par_iter_mut(&mut self) -> rayon::slice::IterMut<'_, LockedNodePage<'a, NS>> {
+        self.writers.par_iter_mut()
+    }
+
+    pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, LockedNodePage<'a, NS>> {
+        self.writers.iter_mut()
+    }
+
+    pub fn into_par_iter(self) -> impl ParallelIterator<Item = LockedNodePage<'a, NS>> + 'a {
+        self.writers.into_par_iter()
+    }
+
+    pub fn ensure_layer(&mut self, layer_id: LayerId) {
+        for writer in &mut self.writers {
+            writer.ensure_layer(layer_id);
+        }
+    }
+
+    pub fn vacuum(&mut self) -> Result<(), StorageError> {
+        for LockedNodePage { page, lock, .. } in &mut self.writers {
+            page.vacuum(lock.deref_mut())?;
+        }
+        Ok(())
+    }
+}
diff --git a/db4-storage/src/pages/mod.rs b/db4-storage/src/pages/mod.rs
new file mode 100644
index 0000000000..dcc1c07b6f
--- /dev/null
+++ b/db4-storage/src/pages/mod.rs
@@ -0,0 +1,454 @@
+use crate::{
+    EID, LocalPOS, VID,
+    api::{edges::EdgeSegmentOps, graph_props::GraphPropSegmentOps, nodes::NodeSegmentOps},
+    error::StorageError,
+    pages::{edge_store::ReadLockedEdgeStorage, node_store::ReadLockedNodeStorage},
+    persist::{
+        config::ConfigOps,
+        control_file::{ControlFileOps, DBState},
+        strategy::PersistenceStrategy,
+    },
+    properties::props_meta_writer::PropsMetaWriter,
+    segments::{edge::segment::MemEdgeSegment, node::segment::MemNodeSegment},
+    state::StateIndex,
+    wal::{GraphWalOps, WalOps},
+};
+use edge_page::writer::EdgeWriter;
+use edge_store::EdgeStorageInner;
+use graph_prop_store::GraphPropStorageInner;
+use node_page::writer::NodeWriter;
+use node_store::NodeStorageInner;
+use parking_lot::RwLockWriteGuard;
+use raphtory_api::core::entities::properties::meta::Meta;
+use rayon::prelude::*;
+use std::{
+    path::{Path, PathBuf},
+    sync::{
+        Arc,
+        atomic::{self, AtomicUsize},
+    },
+};
+use tinyvec::TinyVec;
+
+pub mod edge_page;
+pub mod edge_store;
+pub mod graph_prop_page;
+pub mod graph_prop_store;
+pub mod layer_counter;
+pub mod locked;
+pub mod node_page;
+pub mod node_store;
+pub mod session;
+
+#[cfg(any(test, feature = "test-utils"))]
+pub mod test_utils;
+
+// graph // (node/edges) // segment // layer_ids (0, 1, 2, ...) // actual graphy bits
+
+#[derive(Debug)]
+pub struct GraphStore<
+    NS: NodeSegmentOps<Extension = EXT>,
+    ES: EdgeSegmentOps<Extension = EXT>,
+    GS: GraphPropSegmentOps<Extension = EXT>,
+    EXT: PersistenceStrategy<NS = NS, ES = ES, GS = GS>,
+> {
+    nodes: Arc<NodeStorageInner<NS, EXT>>,
+    edges: Arc<EdgeStorageInner<ES, EXT>>,
+    graph_props: Arc<GraphPropStorageInner<GS, EXT>>,
+    graph_dir: Option<PathBuf>,
+    event_id: AtomicUsize,
+    ext: EXT,
+}
+
+impl<
+    NS: NodeSegmentOps<Extension = EXT>,
+    ES: EdgeSegmentOps<Extension = EXT>,
+    GS: GraphPropSegmentOps<Extension = EXT>,
+    EXT: PersistenceStrategy<NS = NS, ES = ES, GS = GS>,
+> GraphStore<NS, ES, GS, EXT>
+{
+    pub fn flush(&self) -> Result<(), StorageError> {
+        let node_types = self.nodes.prop_meta().get_all_node_types();
+        let config = self.ext.config().with_node_types(node_types);
+
+        if let Some(graph_dir) = self.graph_dir.as_ref() {
+            config.save_to_dir(graph_dir)?;
+        }
+
+        self.nodes.flush()?;
+        self.edges.flush()?;
+        self.graph_props.flush()?;
+
+        Ok(())
+    }
+}
+
+#[derive(Debug)]
+pub struct ReadLockedGraphStore<
+    NS: NodeSegmentOps<Extension = EXT>,
+    ES: EdgeSegmentOps<Extension = EXT>,
+    GS: GraphPropSegmentOps<Extension = EXT>,
+    EXT: PersistenceStrategy<NS = NS, ES = ES, GS = GS>,
+> {
+    pub nodes: Arc<ReadLockedNodeStorage<NS, EXT>>,
+    pub edges: Arc<ReadLockedEdgeStorage<ES, EXT>>,
+    pub graph: Arc<GraphStore<NS, ES, GS, EXT>>,
+}
+
+impl<
+    NS: NodeSegmentOps<Extension = EXT>,
+    ES: EdgeSegmentOps<Extension = EXT>,
+    GS: GraphPropSegmentOps<Extension = EXT>,
+    EXT: PersistenceStrategy<NS = NS, ES = ES, GS = GS>,
+> GraphStore<NS, ES, GS, EXT>
+{
+    pub fn new(graph_dir: Option<&Path>, ext: EXT) -> Self {
+        let node_meta = Meta::new_for_nodes();
+        let edge_meta = Meta::new_for_edges();
+        let graph_props_meta = Meta::new_for_graph_props();
+
+        Self::new_with_meta(graph_dir, node_meta, edge_meta, graph_props_meta, ext)
+    }
+
+    pub fn new_with_meta(
+        graph_dir: Option<&Path>,
+        node_meta: Meta,
+        edge_meta: Meta,
+        graph_props_meta: Meta,
+        ext: EXT,
+    ) -> Self {
+        let nodes_path = graph_dir.map(|graph_dir| graph_dir.join("nodes"));
+        let edges_path = graph_dir.map(|graph_dir| graph_dir.join("edges"));
+        let graph_props_path = graph_dir.map(|graph_dir| graph_dir.join("graph_props"));
+
+        let node_meta = Arc::new(node_meta);
+        let edge_meta = Arc::new(edge_meta);
+        let graph_props_meta = Arc::new(graph_props_meta);
+
+        let node_storage = Arc::new(NodeStorageInner::new_with_meta(
+            nodes_path,
+            node_meta,
+            edge_meta.clone(),
+            ext.clone(),
+        ));
+        let edge_storage = Arc::new(EdgeStorageInner::new_with_meta(
+            edges_path,
+            edge_meta,
+            ext.clone(),
+        ));
+        let graph_prop_storage = Arc::new(GraphPropStorageInner::new_with_meta(
+            graph_props_path.as_deref(),
+            graph_props_meta,
+            ext.clone(),
+        ));
+
+        if let Some(graph_dir) = graph_dir {
+            ext.config()
+                .save_to_dir(graph_dir)
+                .expect("Failed to write config to disk");
+        }
+
+        Self {
+            nodes: node_storage,
+            edges: edge_storage,
+            graph_props: graph_prop_storage,
+            event_id: AtomicUsize::new(0),
+            graph_dir: graph_dir.map(|p| p.to_path_buf()),
+            ext,
+        }
+    }
+
+    pub fn load(graph_dir: impl AsRef<Path>, ext: EXT) -> Result<Self, StorageError> {
+        let nodes_path = graph_dir.as_ref().join("nodes");
+        let edges_path = graph_dir.as_ref().join("edges");
+        let graph_props_path = graph_dir.as_ref().join("graph_props");
+
+        let edge_storage = Arc::new(EdgeStorageInner::load(edges_path, ext.clone())?);
+        let edge_meta = edge_storage.edge_meta().clone();
+        let node_storage = Arc::new(NodeStorageInner::load(nodes_path, edge_meta, ext.clone())?);
+        let node_meta = node_storage.prop_meta();
+
+        // Load graph temporal properties and metadata.
+        let graph_prop_storage =
+            Arc::new(GraphPropStorageInner::load(graph_props_path, ext.clone())?);
+
+        for node_type in ext.config().node_types().iter() {
+            node_meta.get_or_create_node_type_id(node_type);
+        }
+
+        let t_len = edge_storage.t_len();
+
+        Ok(Self {
+            nodes: node_storage,
+            edges: edge_storage,
+            graph_props: graph_prop_storage,
+            event_id: AtomicUsize::new(t_len),
+            graph_dir: Some(graph_dir.as_ref().to_path_buf()),
+            ext,
+        })
+    }
+
+    pub fn read_locked(self: &Arc<Self>) -> ReadLockedGraphStore<NS, ES, GS, EXT> {
+        let nodes = self.nodes.locked().into();
+        let edges = self.edges.locked().into();
+
+        ReadLockedGraphStore {
+            nodes,
+            edges,
+            graph: self.clone(),
+        }
+    }
+
+    pub fn extension(&self) -> &EXT {
+        &self.ext
+    }
+
+    pub fn nodes(&self) -> &Arc<NodeStorageInner<NS, EXT>> {
+        &self.nodes
+    }
+
+    pub fn edges(&self) -> &Arc<EdgeStorageInner<ES, EXT>> {
+        &self.edges
+    }
+
+    pub fn graph_props(&self) -> &Arc<GraphPropStorageInner<GS, EXT>> {
+        &self.graph_props
+    }
+
+    pub fn edge_meta(&self) -> &Meta {
+        self.edges.edge_meta()
+    }
+
+    pub fn node_meta(&self) -> &Meta {
+        self.nodes.prop_meta()
+    }
+
+    pub fn graph_props_meta(&self) -> &Meta {
+        self.graph_props.meta()
+    }
+
+    pub fn earliest(&self) -> i64 {
+        self.nodes
+            .stats()
+            .earliest()
+            .min(self.edges.stats().earliest())
+    }
+
+    pub fn latest(&self) -> i64 {
+        self.nodes.stats().latest().max(self.edges.stats().latest())
+    }
+
+    pub fn node_segment_counts(&self) -> SegmentCounts<VID> {
+        self.nodes.segment_counts()
+    }
+
+    pub fn edge_segment_counts(&self) -> SegmentCounts<EID> {
+        self.edges.segment_counts()
+    }
+
+    pub fn read_event_id(&self) -> usize {
+        self.event_id.load(atomic::Ordering::Relaxed)
+    }
+
+    pub fn set_event_id(&self, event_id: usize) {
+        self.event_id.store(event_id, atomic::Ordering::Relaxed);
+    }
+
+    pub fn next_event_id(&self) -> usize {
+        self.event_id.fetch_add(1, atomic::Ordering::Relaxed)
+    }
+
+    pub fn reserve_event_ids(&self, num_ids: usize) -> usize {
+        self.event_id.fetch_add(num_ids, atomic::Ordering::Relaxed)
+    }
+
+    pub fn set_max_event_id(&self, value: usize) -> usize {
+        self.event_id.fetch_max(value, atomic::Ordering::Relaxed)
+    }
+
+    pub fn node_writer(
+        &self,
+        node_segment: usize,
+    ) -> NodeWriter<'_, RwLockWriteGuard<'_, MemNodeSegment>, NS> {
+        self.nodes().writer(node_segment)
+    }
+
+    pub fn edge_writer(
+        &self,
+        eid: EID,
+    ) -> EdgeWriter<'_, RwLockWriteGuard<'_, MemEdgeSegment>, ES> {
+        self.edges().get_writer(eid)
+    }
+
+    pub fn get_free_writer(&self) -> EdgeWriter<'_, RwLockWriteGuard<'_, MemEdgeSegment>, ES> {
+        self.edges().get_free_writer()
+    }
+
+    pub fn vacuum(self: &Arc<Self>) -> Result<(), StorageError> {
+        let mut locked_nodes = self.nodes.write_locked();
+        let mut locked_edges = self.edges.write_locked();
+
+        locked_nodes.vacuum()?;
+        locked_edges.vacuum()?;
+
+        Ok(())
+    }
+}
+
+#[derive(Debug)]
+pub struct SegmentCounts<I> {
+    max_seg_len: u32,
+    counts: TinyVec<[u32; 32]>, // this might come to be a problem
+    _marker: std::marker::PhantomData<I>,
+}
+
+impl<I: From<usize> + Into<usize>> SegmentCounts<I> {
+    pub fn new(max_seg_len: u32, counts: impl IntoIterator<Item = u32>) -> Self {
+        let counts: TinyVec<[u32; 32]> = counts.into_iter().collect();
+
+        Self {
+            max_seg_len,
+            counts,
+            _marker: std::marker::PhantomData,
+        }
+    }
+
+    pub fn into_iter(self) -> impl Iterator<Item = I> {
+        let max_seg_len = self.max_seg_len as usize;
+        self.counts.into_iter().enumerate().flat_map(move |(i, c)| {
+            let g_pos = i * max_seg_len as usize;
+            (0..c).map(move |offset| I::from(g_pos + offset as usize))
+        })
+    }
+
+    pub fn into_index(self) -> StateIndex<I> {
+        StateIndex::from(self)
+    }
+
+    pub fn counts(&self) -> &[u32] {
+        &self.counts
+    }
+
+    pub(crate) fn max_seg_len(&self) -> u32 {
+        self.max_seg_len
+    }
+}
+impl<I: From<usize> + Send> SegmentCounts<I> {
+    pub fn into_par_iter(self) -> impl ParallelIterator<Item = I> {
+        let max_seg_len = self.max_seg_len as usize;
+        (0..self.counts.len()).into_par_iter().flat_map(move |i| {
+            let c = self.counts[i];
+            let g_pos = i * max_seg_len;
+            (0..c)
+                .into_par_iter()
+                .map(move |offset| I::from(g_pos + offset as usize))
+        })
+    }
+}
+
+impl<
+    NS: NodeSegmentOps<Extension = EXT>,
+    ES: EdgeSegmentOps<Extension = EXT>,
+    GS: GraphPropSegmentOps<Extension = EXT>,
+    EXT: PersistenceStrategy<NS = NS, ES = ES, GS = GS>,
+> Drop for GraphStore<NS, ES, GS, EXT>
+{
+    fn drop(&mut self) {
+        let wal = self.ext.wal();
+        let control_file = self.ext.control_file();
+
+        match self.flush() {
+            Ok(_) => {
+                // Log a checkpoint record in the WAL, indicating that the DB was shutdown
+                // with all the segments flushed to disk.
+                // On startup, recovery is skipped since there are no pending writes to replay.
+                let checkpoint_lsn = match wal.log_shutdown_checkpoint() {
+                    Ok(lsn) => lsn,
+                    Err(err) => {
+                        eprintln!("Failed to log shutdown checkpoint in drop: {err}");
+                        return;
+                    }
+                };
+
+                // Flush up to the end of the WAL stream.
+                let flush_lsn = wal.position();
+
+                if let Err(err) = wal.flush(flush_lsn) {
+                    eprintln!("Failed to flush checkpoint record in drop: {err}");
+                    return;
+                }
+
+                // Record the checkpoint and shutdown state and write control file to disk.
+                control_file.set_checkpoint(checkpoint_lsn);
+                control_file.set_db_state(DBState::Shutdown);
+
+                if let Err(err) = control_file.save() {
+                    eprintln!("Failed to save control file in drop: {err}");
+                    return;
+                }
+            }
+            Err(err) => {
+                eprintln!("Failed to flush storage in drop: {err}")
+            }
+        }
+    }
+}
+
+#[inline(always)]
+pub fn resolve_pos<I: Copy + Into<usize>>(i: I, max_page_len: u32) -> (usize, LocalPOS) {
+    let i = i.into();
+    let seg = i / max_page_len as usize;
+    let pos = i % max_page_len as usize;
+    (seg, LocalPOS(pos as u32))
+}
+
+pub fn row_group_par_iter<I: From<usize>>(
+    chunk_size: usize,
+    num_segments: usize,
+    max_seg_len: u32,
+    max_actual_seg_len: u32,
+) -> impl IndexedParallelIterator<Item = (usize, impl Iterator<Item = I>)> {
+    let (num_chunks, chunk_size) = if num_segments != 0 {
+        let chunk_size = (chunk_size / num_segments).max(1);
+        let num_chunks = (max_seg_len as usize + chunk_size - 1) / chunk_size;
+        (num_chunks, chunk_size)
+    } else {
+        (0, 0)
+    };
+
+    (0..num_chunks).into_par_iter().map(move |chunk_id| {
+        let start = chunk_id * chunk_size;
+        let end = ((chunk_id + 1) * chunk_size).min(max_actual_seg_len as usize);
+
+        let iter = (start..end).flat_map(move |x| {
+            (0..num_segments).map(move |seg| I::from(seg * max_seg_len as usize + x))
+        });
+
+        (chunk_id, iter)
+    })
+}
+
+#[cfg(test)]
+mod test {
+    use rayon::iter::ParallelIterator;
+
+    #[test]
+    fn test_iterleave() {
+        let chunk_size = 3;
+        let num_segments = 3;
+        let max_seg_len = 4;
+
+        let actual = super::row_group_par_iter(chunk_size, num_segments, max_seg_len, max_seg_len)
+            .map(|(c, items)| (c, items.collect::<Vec<_>>()))
+            .collect::<Vec<_>>();
+
+        let expected = vec![
+            (0, vec![0, 4, 8]),
+            (1, vec![1, 5, 9]),
+            (2, vec![2, 6, 10]),
+            (3, vec![3, 7, 11]),
+        ];
+
+        assert_eq!(actual, expected);
+    }
+}
diff --git a/db4-storage/src/pages/node_page/mod.rs b/db4-storage/src/pages/node_page/mod.rs
new file mode 100644
index 0000000000..d3baa81782
--- /dev/null
+++ b/db4-storage/src/pages/node_page/mod.rs
@@ -0,0 +1 @@
+pub mod writer;
diff --git a/db4-storage/src/pages/node_page/writer.rs b/db4-storage/src/pages/node_page/writer.rs
new file mode 100644
index 0000000000..ccc81acc3a
--- /dev/null
+++ b/db4-storage/src/pages/node_page/writer.rs
@@ -0,0 +1,300 @@
+use crate::{
+    LocalPOS,
+    api::nodes::NodeSegmentOps,
+    error::StorageError,
+    pages::{layer_counter::GraphStats, resolve_pos},
+    segments::node::segment::MemNodeSegment,
+    wal::LSN,
+};
+use parking_lot::RwLockWriteGuard;
+use raphtory_api::core::entities::{
+    EID, GID, LayerId, VID,
+    properties::{
+        meta::{NODE_ID_IDX, NODE_TYPE_IDX, STATIC_GRAPH_LAYER_ID},
+        prop::{AsPropRef, Prop},
+    },
+};
+use raphtory_core::{
+    entities::{ELID, GidRef},
+    storage::timeindex::AsTime,
+};
+use std::ops::DerefMut;
+
+#[derive(Debug)]
+pub struct NodeWriter<'a, MP: DerefMut<Target = MemNodeSegment> + 'a, NS: NodeSegmentOps> {
+    pub page: &'a NS,
+    pub mut_segment: MP,
+    pub l_counter: &'a GraphStats,
+    pub old_est_size: usize,
+}
+
+impl<'a, MP: DerefMut<Target = MemNodeSegment> + 'a, NS: NodeSegmentOps> NodeWriter<'a, MP, NS> {
+    pub fn new(page: &'a NS, global_num_nodes: &'a GraphStats, writer: MP) -> Self {
+        let old_est_size = writer.est_size();
+        Self {
+            page,
+            mut_segment: writer,
+            l_counter: global_num_nodes,
+            old_est_size,
+        }
+    }
+    #[inline(always)]
+    pub fn resolve_pos(&self, node_id: VID) -> Option<LocalPOS> {
+        let (page, pos) = resolve_pos(node_id, self.mut_segment.max_page_len());
+
+        if page == self.mut_segment.segment_id() {
+            Some(pos)
+        } else {
+            None
+        }
+    }
+
+    pub fn add_outbound_edge<T: AsTime>(
+        &mut self,
+        t: Option<T>,
+        src_pos: impl Into<LocalPOS>,
+        dst: impl Into<VID>,
+        e_id: impl Into<ELID>,
+    ) {
+        self.add_outbound_edge_inner(t, src_pos, dst, e_id);
+    }
+
+    pub fn add_static_outbound_edge(
+        &mut self,
+        src_pos: LocalPOS,
+        dst: impl Into<VID>,
+        e_id: impl Into<EID>,
+    ) {
+        let e_id = e_id.into();
+        self.add_outbound_edge_inner::<i64>(
+            None,
+            src_pos,
+            dst,
+            e_id.with_layer(STATIC_GRAPH_LAYER_ID),
+        );
+    }
+
+    fn add_outbound_edge_inner<T: AsTime>(
+        &mut self,
+        t: Option<T>,
+        src_pos: impl Into<LocalPOS>,
+        dst: impl Into<VID>,
+        e_id: impl Into<ELID>,
+    ) {
+        let src_pos = src_pos.into();
+        let dst = dst.into();
+        if let Some(t) = t {
+            self.l_counter.update_time(t.t());
+        }
+
+        let e_id = e_id.into();
+        let layer_id = e_id.layer();
+        let (is_new_node, add) = self.mut_segment.add_outbound_edge(t, src_pos, dst, e_id);
+        self.mut_segment.increment_est_size(add);
+
+        if is_new_node && !self.page.has_node(src_pos, layer_id) {
+            self.l_counter.increment(layer_id);
+        }
+    }
+
+    pub fn add_inbound_edge<T: AsTime>(
+        &mut self,
+        t: Option<T>,
+        dst_pos: impl Into<LocalPOS>,
+        src: impl Into<VID>,
+        e_id: impl Into<ELID>,
+    ) {
+        self.add_inbound_edge_inner(t, dst_pos, src, e_id);
+    }
+
+    pub fn add_static_inbound_edge(
+        &mut self,
+        dst_pos: LocalPOS,
+        src: impl Into<VID>,
+        e_id: impl Into<EID>,
+    ) {
+        let e_id = e_id.into();
+        self.add_inbound_edge_inner::<i64>(
+            None,
+            dst_pos,
+            src,
+            e_id.with_layer(STATIC_GRAPH_LAYER_ID),
+        );
+    }
+
+    fn add_inbound_edge_inner<T: AsTime>(
+        &mut self,
+        t: Option<T>,
+        dst_pos: impl Into<LocalPOS>,
+        src: impl Into<VID>,
+        e_id: impl Into<ELID>,
+    ) {
+        let e_id = e_id.into();
+        let src = src.into();
+        if let Some(t) = t {
+            self.l_counter.update_time(t.t());
+        }
+        let layer = e_id.layer();
+        let dst_pos = dst_pos.into();
+        let (is_new_node, add) = self.mut_segment.add_inbound_edge(t, dst_pos, src, e_id);
+
+        self.mut_segment.increment_est_size(add);
+
+        if is_new_node && !self.page.has_node(dst_pos, layer) {
+            self.l_counter.increment(layer);
+        }
+    }
+
+    pub fn add_props<T: AsTime, P: AsPropRef>(
+        &mut self,
+        t: T,
+        pos: LocalPOS,
+        layer_id: LayerId,
+        props: impl IntoIterator<Item = (usize, P)>,
+    ) {
+        self.l_counter.update_time(t.t());
+        let (is_new_node, add) = self.mut_segment.add_props(t, pos, layer_id, props);
+        self.mut_segment.increment_est_size(add);
+        if is_new_node && !self.page.has_node(pos, layer_id) {
+            self.l_counter.increment(layer_id);
+        }
+    }
+
+    pub fn check_metadata<P: AsPropRef>(
+        &self,
+        pos: LocalPOS,
+        layer_id: LayerId,
+        props: &[(usize, P)],
+    ) -> Result<(), StorageError> {
+        self.mut_segment.check_metadata(pos, layer_id, props)
+    }
+
+    pub fn update_c_props<P: AsPropRef>(
+        &mut self,
+        pos: LocalPOS,
+        layer_id: LayerId,
+        props: impl IntoIterator<Item = (usize, P)>,
+    ) {
+        let (is_new_node, add) = self.mut_segment.update_metadata(pos, layer_id, props);
+        self.mut_segment.increment_est_size(add);
+        if is_new_node && !self.page.has_node(pos, layer_id) {
+            self.l_counter.increment(layer_id);
+        }
+    }
+
+    pub fn get_metadata(&self, pos: LocalPOS, layer_id: LayerId, prop_id: usize) -> Option<Prop> {
+        self.mut_segment.get_metadata(pos, layer_id, prop_id)
+    }
+
+    pub fn update_timestamp<T: AsTime>(&mut self, t: T, pos: LocalPOS, e_id: ELID) {
+        self.l_counter.update_time(t.t());
+        let add = self.mut_segment.update_timestamp(t, pos, e_id);
+        self.mut_segment.increment_est_size(add);
+    }
+
+    #[inline]
+    pub fn get_out_edge(&self, pos: LocalPOS, dst: VID, layer_id: LayerId) -> Option<EID> {
+        self.page
+            .get_out_edge(pos, dst, layer_id, self.mut_segment.deref())
+    }
+
+    pub fn get_inb_edge(&self, pos: LocalPOS, src: VID, layer_id: LayerId) -> Option<EID> {
+        self.page
+            .get_inb_edge(pos, src, layer_id, self.mut_segment.deref())
+    }
+
+    pub fn store_node_id_and_node_type(
+        &mut self,
+        pos: LocalPOS,
+        layer_id: LayerId,
+        gid: GidRef<'_>,
+        node_type: usize,
+    ) {
+        let node_type = (node_type != 0).then_some(node_type);
+        self.update_c_props(pos, layer_id, node_info_as_props(Some(gid), node_type));
+    }
+
+    pub fn store_node_id(&mut self, pos: LocalPOS, layer_id: LayerId, gid: GID) {
+        let gid = match gid {
+            GID::U64(id) => Prop::U64(id),
+            GID::Str(s) => Prop::str(s),
+        };
+        let props = [(NODE_ID_IDX, gid)];
+        self.update_c_props(pos, layer_id, props);
+    }
+
+    pub fn store_node_type(&mut self, pos: LocalPOS, layer_id: LayerId, node_type: usize) {
+        let props = [(NODE_TYPE_IDX, Prop::U64(node_type as u64))];
+        self.update_c_props(pos, layer_id, props);
+    }
+
+    pub fn update_deletion_time<T: AsTime>(&mut self, t: T, node: LocalPOS, e_id: ELID) {
+        self.update_timestamp(t, node, e_id);
+    }
+
+    pub fn increment_seg_num_nodes(&mut self) {
+        self.page
+            .increment_num_nodes(self.mut_segment.max_page_len());
+    }
+
+    pub fn has_node(&self, node: LocalPOS, layer_id: LayerId) -> bool {
+        self.mut_segment.has_node(node, layer_id) || self.page.has_node(node, layer_id)
+    }
+
+    pub fn set_lsn(&mut self, lsn: LSN) {
+        self.mut_segment.set_lsn(lsn);
+    }
+}
+
+impl<'a, NS: NodeSegmentOps> NodeWriter<'a, RwLockWriteGuard<'a, MemNodeSegment>, NS> {
+    pub fn unlocked<R>(&mut self, op: impl FnOnce() -> R) -> R {
+        RwLockWriteGuard::unlocked(&mut self.mut_segment, op)
+    }
+}
+
+pub fn node_info_as_props(
+    gid: Option<GidRef>,
+    node_type: Option<usize>,
+) -> impl Iterator<Item = (usize, Prop)> {
+    gid.into_iter().map(|g| (NODE_ID_IDX, g.into())).chain(
+        node_type
+            .into_iter()
+            .map(|nt| (NODE_TYPE_IDX, Prop::U64(nt as u64))),
+    )
+}
+
+impl<'a, MP: DerefMut<Target = MemNodeSegment> + 'a, NS: NodeSegmentOps> Drop
+    for NodeWriter<'a, MP, NS>
+{
+    fn drop(&mut self) {
+        self.mut_segment
+            .increment_global_est_size(self.mut_segment.est_size() - self.old_est_size);
+        self.page
+            .notify_write(self.mut_segment.deref_mut())
+            .expect("Failed to persist node page");
+    }
+}
+
+/// Holds writers for src and dst node segments when adding an edge.
+/// If both nodes are in the same segment, `dst` is `None` and `src` is used for both.
+pub struct NodeWriters<'a, MP: DerefMut<Target = MemNodeSegment>, NS: NodeSegmentOps> {
+    pub src: NodeWriter<'a, MP, NS>,
+    pub dst: Option<NodeWriter<'a, MP, NS>>,
+}
+
+impl<'a, MP: DerefMut<Target = MemNodeSegment>, NS: NodeSegmentOps> NodeWriters<'a, MP, NS> {
+    pub fn get_mut_src(&mut self) -> &mut NodeWriter<'a, MP, NS> {
+        &mut self.src
+    }
+
+    pub fn get_mut_dst(&mut self) -> &mut NodeWriter<'a, MP, NS> {
+        self.dst.as_mut().unwrap_or(&mut self.src)
+    }
+
+    pub fn set_lsn(&mut self, lsn: LSN) {
+        self.src.set_lsn(lsn);
+        if let Some(dst) = &mut self.dst {
+            dst.set_lsn(lsn);
+        }
+    }
+}
diff --git a/db4-storage/src/pages/node_store.rs b/db4-storage/src/pages/node_store.rs
new file mode 100644
index 0000000000..b28420d1b3
--- /dev/null
+++ b/db4-storage/src/pages/node_store.rs
@@ -0,0 +1,647 @@
+use super::{node_page::writer::NodeWriter, resolve_pos};
+use crate::{
+    LocalPOS,
+    api::nodes::{LockedNSSegment, NodeSegmentOps},
+    error::StorageError,
+    pages::{
+        SegmentCounts,
+        layer_counter::GraphStats,
+        locked::nodes::{LockedNodePage, WriteLockedNodePages},
+        row_group_par_iter,
+    },
+    persist::{config::ConfigOps, strategy::PersistenceStrategy},
+    segments::node::segment::MemNodeSegment,
+};
+use parking_lot::{RwLock, RwLockWriteGuard};
+use raphtory_api::core::entities::{GidType, LayerId, properties::meta::Meta};
+use raphtory_core::{
+    entities::{EID, VID},
+    storage::timeindex::AsTime,
+};
+use rayon::prelude::*;
+use std::{
+    collections::HashMap,
+    ops::Deref,
+    path::{Path, PathBuf},
+    sync::{Arc, LazyLock, atomic::AtomicU32},
+};
+
+// graph // (nodes|edges) // graph segments // layers // chunks
+pub static N: LazyLock<usize> = LazyLock::new(|| rayon::current_num_threads());
+
+#[derive(Debug)]
+pub struct NodeStorageInner<NS, EXT> {
+    segments: boxcar::Vec<Arc<NS>>,
+    stats: Arc<GraphStats>,
+
+    /// Contains ids of segments that can accomodate new nodes.
+    free_segments: Box<[RwLock<usize>]>,
+
+    nodes_path: Option<PathBuf>,
+    node_meta: Arc<Meta>,
+    edge_meta: Arc<Meta>,
+    ext: EXT,
+}
+
+#[derive(Debug)]
+pub struct ReadLockedNodeStorage<NS: NodeSegmentOps<Extension = EXT>, EXT> {
+    storage: Arc<NodeStorageInner<NS, EXT>>,
+    locked_segments: Box<[NS::ArcLockedSegment]>,
+}
+
+impl<NS: NodeSegmentOps<Extension = EXT>, EXT: PersistenceStrategy<NS = NS>>
+    ReadLockedNodeStorage<NS, EXT>
+{
+    pub fn node_ref(
+        &self,
+        node: impl Into<VID>,
+    ) -> <<NS as NodeSegmentOps>::ArcLockedSegment as LockedNSSegment>::EntryRef<'_> {
+        let (segment_id, pos) = self.storage.resolve_pos(node);
+        let locked_segment = &self.locked_segments[segment_id];
+        locked_segment.entry_ref(pos)
+    }
+
+    pub fn try_node_ref(
+        &self,
+        node: VID,
+    ) -> Option<<<NS as NodeSegmentOps>::ArcLockedSegment as LockedNSSegment>::EntryRef<'_>> {
+        let (segment_id, pos) = self.storage.resolve_pos(node);
+        let locked_segment = &self.locked_segments.get(segment_id)?;
+        if pos.0 < locked_segment.num_nodes() {
+            Some(locked_segment.entry_ref(pos))
+        } else {
+            None
+        }
+    }
+
+    pub fn len(&self) -> usize {
+        self.storage.num_nodes()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    pub fn iter(
+        &self,
+    ) -> impl Iterator<
+        Item = <<NS as NodeSegmentOps>::ArcLockedSegment as LockedNSSegment>::EntryRef<'_>,
+    > + '_ {
+        self.locked_segments
+            .iter()
+            .flat_map(move |segment| segment.iter_entries())
+    }
+
+    pub fn segment_counts(&self) -> SegmentCounts<VID> {
+        SegmentCounts::new(
+            self.storage.max_segment_len(),
+            self.locked_segments.iter().map(|seg| seg.num_nodes()),
+        )
+    }
+
+    pub fn par_iter(
+        &self,
+    ) -> impl rayon::iter::ParallelIterator<
+        Item = <<NS as NodeSegmentOps>::ArcLockedSegment as LockedNSSegment>::EntryRef<'_>,
+    > + '_ {
+        self.locked_segments
+            .par_iter()
+            .flat_map(move |segment| segment.par_iter_entries())
+    }
+
+    pub fn row_groups_par_iter(
+        &self,
+    ) -> impl IndexedParallelIterator<Item = (usize, impl Iterator<Item = VID> + '_)> {
+        let max_actual_seg_len = self
+            .locked_segments
+            .iter()
+            .map(|seg| seg.num_nodes())
+            .max()
+            .unwrap_or(0);
+        row_group_par_iter(
+            self.storage.max_segment_len() as usize,
+            self.locked_segments.len(),
+            self.storage.max_segment_len(),
+            max_actual_seg_len,
+        )
+        .map(|(s_id, iter)| (s_id, iter.filter(|vid| self.has_vid(*vid))))
+    }
+
+    fn has_vid(&self, vid: VID) -> bool {
+        let (segment_id, pos) = self.storage.resolve_pos(vid);
+        segment_id < self.locked_segments.len()
+            && pos.0 < self.locked_segments[segment_id].num_nodes()
+    }
+}
+
+impl<NS: NodeSegmentOps<Extension = EXT>, EXT: PersistenceStrategy<NS = NS>>
+    NodeStorageInner<NS, EXT>
+{
+    pub fn prop_meta(&self) -> &Arc<Meta> {
+        &self.node_meta
+    }
+
+    pub fn num_layers(&self) -> usize {
+        self.stats.len()
+    }
+
+    pub fn num_nodes(&self) -> usize {
+        self.stats.get(LayerId(0))
+    }
+
+    // FIXME: this should be called by the high level APIs on layer filter
+    pub fn layer_num_nodes(&self, layer_id: usize) -> usize {
+        self.stats.get(LayerId(layer_id))
+    }
+
+    pub fn stats(&self) -> &Arc<GraphStats> {
+        &self.stats
+    }
+
+    pub fn segments_iter(&self) -> impl Iterator<Item = &NS> {
+        let count = self.segments.count();
+        (0..count).map(|id| {
+            self.get_segment(id)
+                .expect("segment should exist given count")
+        })
+    }
+
+    pub fn num_segments(&self) -> usize {
+        self.segments.count()
+    }
+
+    // pub fn segments(&self) -> &boxcar::Vec<Arc<NS>> {
+    //     &self.segments
+    // }
+
+    pub fn segments_par_iter(&self) -> impl ParallelIterator<Item = &NS> {
+        let len = self.segments.count();
+        (0..len)
+            .into_par_iter()
+            .filter_map(|idx| self.segments.get(idx).map(|seg| seg.deref()))
+    }
+
+    pub fn nodes_path(&self) -> Option<&Path> {
+        self.nodes_path.as_deref()
+    }
+
+    /// Return the position of the chunk and the position within the chunk
+    pub fn resolve_pos(&self, i: impl Into<VID>) -> (usize, LocalPOS) {
+        resolve_pos(i.into(), self.max_segment_len())
+    }
+
+    pub fn max_segment_len(&self) -> u32 {
+        self.ext.config().max_node_page_len()
+    }
+}
+
+impl<NS: NodeSegmentOps<Extension = EXT>, EXT: PersistenceStrategy<NS = NS>>
+    NodeStorageInner<NS, EXT>
+{
+    pub fn new_with_meta(
+        nodes_path: Option<PathBuf>,
+        node_meta: Arc<Meta>,
+        edge_meta: Arc<Meta>,
+        ext: EXT,
+    ) -> Self {
+        let free_segments = (0..(*N)).map(RwLock::new).collect::<Box<[_]>>();
+        let empty = Self {
+            segments: boxcar::Vec::new(),
+            stats: GraphStats::new().into(),
+            free_segments: free_segments.try_into().unwrap(),
+            nodes_path,
+            node_meta,
+            edge_meta,
+            ext,
+        };
+        let layer_mapper = empty.node_meta.layer_meta();
+        let prop_mapper = empty.node_meta.temporal_prop_mapper();
+        let metadata_mapper = empty.node_meta.metadata_mapper();
+        if layer_mapper.num_fields() > 0
+            || prop_mapper.num_fields() > 0
+            || metadata_mapper.num_fields() > 0
+        {
+            let segment = empty.get_or_create_segment(0);
+            let mut head = segment.head_mut();
+            if prop_mapper.num_fields() > 0 {
+                head.get_or_create_layer(LayerId(0))
+                    .properties_mut()
+                    .set_has_properties()
+            }
+            segment.set_dirty(true);
+        }
+        empty
+    }
+
+    pub fn locked(self: &Arc<Self>) -> ReadLockedNodeStorage<NS, EXT> {
+        let locked_segments = self
+            .segments_iter()
+            .map(|segment| segment.locked())
+            .collect::<Box<_>>();
+        ReadLockedNodeStorage {
+            storage: self.clone(),
+            locked_segments,
+        }
+    }
+
+    pub fn write_locked<'a>(&'a self) -> WriteLockedNodePages<'a, NS> {
+        WriteLockedNodePages::new(
+            self.segments
+                .iter()
+                .map(|(page_id, page)| {
+                    LockedNodePage::new(
+                        page_id,
+                        &self.stats,
+                        self.max_segment_len(),
+                        page.as_ref(),
+                        page.head_mut(),
+                    )
+                })
+                .collect(),
+        )
+    }
+
+    pub fn reserve_vid(&self, row: usize) -> VID {
+        let (seg, pos) = self.reserve_free_pos(row);
+        pos.as_vid(seg, self.max_segment_len())
+    }
+
+    pub fn reserve_free_pos(&self, row: usize) -> (usize, LocalPOS) {
+        let slot_idx = row % *N;
+        let maybe_free_page = {
+            let page_id = *self.free_segments[slot_idx].read_recursive();
+            let page = self.segments.get(page_id);
+
+            page.and_then(|page| {
+                self.reserve_segment_row(page)
+                    .map(|pos| (page.segment_id(), LocalPOS(pos)))
+            })
+        };
+
+        if let Some(reserved_pos) = maybe_free_page {
+            reserved_pos
+        } else {
+            // not lucky, go wait on your slot
+            let mut slot = self.free_segments[slot_idx].write();
+            loop {
+                if let Some(page) = self.segments.get(*slot)
+                    && let Some(pos) = self.reserve_segment_row(page)
+                {
+                    return (page.segment_id(), LocalPOS(pos));
+                }
+                *slot = self.push_new_segment();
+            }
+        }
+    }
+
+    /// Select a segment using `row` as a hint and reserves `num_rows` in that segment.
+    /// Returns the reserved position and a locked writer for that segment.
+    ///
+    /// # Deadlock Safety: do not hold any node segment locks when calling this function!
+    pub fn reserve_and_lock_segment(
+        &self,
+        row: usize,
+        num_rows: u32,
+    ) -> (
+        LocalPOS,
+        NodeWriter<'_, RwLockWriteGuard<'_, MemNodeSegment>, NS>,
+    ) {
+        let slot_idx = row % *N;
+        // No point in multiple threads getting past here as they would just content on the writer lock
+        let mut slot = self.free_segments[slot_idx].write();
+        let mut segment_id = *slot;
+
+        let writer = self.writer(segment_id);
+        match self.reserve_segment_rows(writer.page, num_rows) {
+            None => {
+                // The current segment is full, drop its lock and push a new free segment
+                drop(writer);
+                segment_id = self.push_new_segment();
+                *slot = segment_id;
+                let writer = self.writer(segment_id);
+                let local_pos = self
+                    .reserve_segment_rows(writer.page, num_rows)
+                    .expect("new segment should never be full");
+                (LocalPOS(local_pos), writer)
+            }
+            Some(local_pos) => (LocalPOS(local_pos), writer),
+        }
+    }
+
+    /// Reserves a single row in the given segment and returns the position if successful.
+    /// Returns `None` if the segment is full.
+    pub fn reserve_segment_row(&self, segment: &NS) -> Option<u32> {
+        self.reserve_segment_rows(segment, 1)
+    }
+
+    /// Reserves `rows` in the given segment and returns the position if successful.
+    /// Returns `None` if the segment is full.
+    fn reserve_segment_rows(&self, segment: &NS, rows: u32) -> Option<u32> {
+        increment_and_clamp(segment.nodes_counter(), rows, self.max_segment_len())
+    }
+
+    fn push_new_segment(&self) -> usize {
+        let segment_id = self.segments.push_with(|segment_id| {
+            Arc::new(NS::new(
+                segment_id,
+                self.node_meta.clone(),
+                self.edge_meta.clone(),
+                self.nodes_path.clone(),
+                self.ext.clone(),
+            ))
+        });
+
+        while self.segments.get(segment_id).is_none() {
+            std::thread::yield_now();
+        }
+
+        segment_id
+    }
+
+    pub fn node<'a>(&'a self, node: impl Into<VID>) -> NS::Entry<'a> {
+        let (page_id, pos) = self.resolve_pos(node);
+        let node_page = self
+            .get_segment(page_id)
+            .expect("Internal error: page not found");
+        node_page.entry(pos)
+    }
+
+    pub fn try_node(&self, node: VID) -> Option<NS::Entry<'_>> {
+        let (page_id, pos) = self.resolve_pos(node);
+        let node_page = self.segments.get(page_id)?;
+        if pos.0 < node_page.num_nodes() {
+            Some(node_page.entry(pos))
+        } else {
+            None
+        }
+    }
+
+    #[inline(always)]
+    pub fn writer<'a>(
+        &'a self,
+        segment_id: usize,
+    ) -> NodeWriter<'a, RwLockWriteGuard<'a, MemNodeSegment>, NS> {
+        let segment = self.get_or_create_segment(segment_id);
+        let head = segment.head_mut();
+        NodeWriter::new(segment, &self.stats, head)
+    }
+
+    pub fn try_writer<'a>(
+        &'a self,
+        segment_id: usize,
+    ) -> Option<NodeWriter<'a, RwLockWriteGuard<'a, MemNodeSegment>, NS>> {
+        let segment = self.get_or_create_segment(segment_id);
+        let head = segment.try_head_mut()?;
+        Some(NodeWriter::new(segment, &self.stats, head))
+    }
+
+    pub fn id_type(&self) -> Option<GidType> {
+        self.node_meta
+            .metadata_mapper()
+            .d_types()
+            .first()
+            .and_then(GidType::from_prop_type)
+    }
+
+    pub fn load(
+        nodes_path: impl AsRef<Path>,
+        edge_meta: Arc<Meta>,
+        ext: EXT,
+    ) -> Result<Self, StorageError> {
+        let nodes_path = nodes_path.as_ref();
+        let max_page_len = ext.config().max_node_page_len();
+        let node_meta = Arc::new(Meta::new_for_nodes());
+
+        if !nodes_path.exists() {
+            return Ok(Self::new_with_meta(
+                Some(nodes_path.to_path_buf()),
+                node_meta,
+                edge_meta,
+                ext.clone(),
+            ));
+        }
+
+        let mut pages = std::fs::read_dir(nodes_path)?
+            .par_bridge()
+            .filter(|entry| {
+                entry
+                    .as_ref()
+                    .ok()
+                    .and_then(|entry| entry.file_type().ok().map(|ft| ft.is_dir()))
+                    .unwrap_or_default()
+            })
+            .filter_map(|entry| {
+                let entry = entry.ok()?;
+                let page_id = entry
+                    .path()
+                    .file_stem()
+                    .and_then(|name| name.to_str().and_then(|name| name.parse::<usize>().ok()))?;
+                let page = NS::load(
+                    page_id,
+                    node_meta.clone(),
+                    edge_meta.clone(),
+                    nodes_path,
+                    ext.clone(),
+                )
+                .map(|page| (page_id, page));
+                Some(page)
+            })
+            .collect::<Result<HashMap<_, _>, _>>()?;
+
+        if pages.is_empty() {
+            return Err(StorageError::EmptyGraphDir(nodes_path.to_path_buf()));
+        }
+
+        let max_page = Iterator::max(pages.keys().copied()).unwrap();
+
+        let pages = (0..=max_page)
+            .map(|page_id| {
+                let np = pages.remove(&page_id).unwrap_or_else(|| {
+                    NS::new(
+                        page_id,
+                        node_meta.clone(),
+                        edge_meta.clone(),
+                        Some(nodes_path.to_path_buf()),
+                        ext.clone(),
+                    )
+                });
+                Arc::new(np)
+            })
+            .collect::<boxcar::Vec<_>>();
+
+        let first_page = pages.iter().next().unwrap().1;
+        let first_p_id = first_page.segment_id();
+
+        if first_p_id != 0 {
+            return Err(StorageError::GenericFailure(format!(
+                "First page id is not 0 in {nodes_path:?}"
+            )));
+        }
+
+        let mut layer_counts = vec![];
+
+        for (_, page) in pages.iter() {
+            for layer_id in 0..page.num_layers() {
+                let count = page.layer_count(LayerId(layer_id)) as usize;
+                if layer_counts.len() <= layer_id {
+                    layer_counts.resize(layer_id + 1, 0);
+                }
+                layer_counts[layer_id] += count;
+            }
+        }
+
+        let earliest = pages
+            .iter()
+            .filter_map(|(_, page)| page.earliest().filter(|t| t.t() != i64::MAX))
+            .map(|t| t.t())
+            .min()
+            .unwrap_or(i64::MAX);
+
+        let latest = pages
+            .iter()
+            .filter_map(|(_, page)| page.latest().filter(|t| t.t() != i64::MIN))
+            .map(|t| t.t())
+            .max()
+            .unwrap_or(i64::MIN);
+
+        let mut free_pages = pages
+            .iter()
+            .filter_map(|(_, page)| {
+                let len = page.num_nodes();
+                if len < max_page_len {
+                    Some(RwLock::new(page.segment_id()))
+                } else {
+                    None
+                }
+            })
+            .collect::<Vec<_>>();
+
+        let mut next_free_page = free_pages
+            .last()
+            .map(|page| *(page.read()))
+            .map(|last| last + 1)
+            .unwrap_or_else(|| pages.count());
+
+        free_pages.resize_with(*N, || {
+            let lock = RwLock::new(next_free_page);
+            next_free_page += 1;
+            lock
+        });
+
+        let stats = GraphStats::load(layer_counts, earliest, latest);
+
+        Ok(Self {
+            segments: pages,
+            free_segments: free_pages.try_into().unwrap(),
+            nodes_path: Some(nodes_path.to_path_buf()),
+            stats: stats.into(),
+            node_meta,
+            edge_meta,
+            ext,
+        })
+    }
+
+    pub fn get_edge(&self, src: VID, dst: VID, layer_id: LayerId) -> Option<EID> {
+        let (src_chunk, src_pos) = self.resolve_pos(src);
+        if src_chunk >= self.segments.count() {
+            return None;
+        }
+        let src_page = &self.segments[src_chunk];
+        src_page.get_out_edge(src_pos, dst, layer_id, src_page.head())
+    }
+
+    pub fn grow(&self, new_len: usize) {
+        self.get_or_create_segment(new_len - 1);
+    }
+
+    pub fn get_segment(&self, segment_id: usize) -> Option<&NS> {
+        self.segments
+            .get(segment_id)
+            .map(|seg| seg.deref())
+            .or_else(|| {
+                let count = self.segments.count();
+                if segment_id < count {
+                    // Another thread has allocated the segment, wait for it to be added.
+                    Some(self.wait_for_segment(segment_id).deref())
+                } else {
+                    None
+                }
+            })
+    }
+
+    fn wait_for_segment(&self, segment_id: usize) -> &Arc<NS> {
+        loop {
+            if let Some(segment) = self.segments.get(segment_id) {
+                return segment;
+            } else {
+                // Wait for the segment to be created.
+                std::thread::yield_now();
+            }
+        }
+    }
+
+    pub fn get_or_create_segment(&self, segment_id: usize) -> &Arc<NS> {
+        if let Some(segment) = self.segments.get(segment_id) {
+            return segment;
+        }
+
+        let count = self.segments.count();
+
+        if segment_id < count {
+            // Another thread has allocated the segment, wait for it to be added.
+            self.wait_for_segment(segment_id)
+        } else {
+            // we need to create the segment.
+            self.segments.reserve(segment_id + 1 - count);
+
+            loop {
+                // Create consecutive segments until the required segment is created.
+                let new_segment_id = self.segments.push_with(|segment_id| {
+                    Arc::new(NS::new(
+                        segment_id,
+                        self.node_meta.clone(),
+                        self.edge_meta.clone(),
+                        self.nodes_path.clone(),
+                        self.ext.clone(),
+                    ))
+                });
+
+                // The segment has been created.
+                if segment_id <= new_segment_id {
+                    return self.wait_for_segment(segment_id);
+                }
+            }
+        }
+    }
+
+    pub(crate) fn segment_counts(&self) -> SegmentCounts<VID> {
+        SegmentCounts::new(
+            self.max_segment_len(),
+            self.segments_iter().map(|seg| seg.num_nodes()),
+        )
+    }
+
+    pub(crate) fn flush(&self) -> Result<(), StorageError> {
+        self.segments_par_iter().try_for_each(|seg| seg.flush())
+    }
+}
+
+/// Atomically increments `counter` and returns the previous value, but only if the result stays
+/// within bounds.
+/// If the result exceeds `limit`, leaves the counter unchanged and returns `None`.
+pub fn increment_and_clamp(counter: &AtomicU32, increment: u32, limit: u32) -> Option<u32> {
+    counter
+        .fetch_update(
+            std::sync::atomic::Ordering::Relaxed,
+            std::sync::atomic::Ordering::Relaxed,
+            |current| {
+                let updated = current + increment;
+                if updated <= limit {
+                    Some(updated)
+                } else {
+                    None
+                }
+            },
+        )
+        .ok()
+}
diff --git a/db4-storage/src/pages/session.rs b/db4-storage/src/pages/session.rs
new file mode 100644
index 0000000000..6beed825ad
--- /dev/null
+++ b/db4-storage/src/pages/session.rs
@@ -0,0 +1,207 @@
+use super::{
+    GraphStore, edge_page::writer::EdgeWriter, node_page::writer::NodeWriters, resolve_pos,
+};
+use crate::{
+    api::{edges::EdgeSegmentOps, graph_props::GraphPropSegmentOps, nodes::NodeSegmentOps},
+    persist::strategy::PersistenceStrategy,
+    segments::{edge::segment::MemEdgeSegment, node::segment::MemNodeSegment},
+    wal::LSN,
+};
+use parking_lot::RwLockWriteGuard;
+use raphtory_api::core::{
+    entities::properties::{meta::STATIC_GRAPH_LAYER_ID, prop::Prop},
+    storage::dict_mapper::MaybeNew,
+};
+use raphtory_core::{
+    entities::{EID, ELID, VID},
+    storage::timeindex::AsTime,
+};
+
+pub struct EdgeWriteSession<
+    'a,
+    NS: NodeSegmentOps<Extension = EXT>,
+    ES: EdgeSegmentOps<Extension = EXT>,
+    GS: GraphPropSegmentOps<Extension = EXT>,
+    EXT: PersistenceStrategy<NS = NS, ES = ES, GS = GS>,
+> {
+    node_writers: NodeWriters<'a, RwLockWriteGuard<'a, MemNodeSegment>, NS>,
+    edge_writer: EdgeWriter<'a, RwLockWriteGuard<'a, MemEdgeSegment>, ES>,
+    graph: &'a GraphStore<NS, ES, GS, EXT>,
+}
+
+impl<
+    'a,
+    NS: NodeSegmentOps<Extension = EXT>,
+    ES: EdgeSegmentOps<Extension = EXT>,
+    GS: GraphPropSegmentOps<Extension = EXT>,
+    EXT: PersistenceStrategy<NS = NS, ES = ES, GS = GS>,
+> EdgeWriteSession<'a, NS, ES, GS, EXT>
+{
+    pub fn new(
+        node_writers: NodeWriters<'a, RwLockWriteGuard<'a, MemNodeSegment>, NS>,
+        edge_writer: EdgeWriter<'a, RwLockWriteGuard<'a, MemEdgeSegment>, ES>,
+        graph: &'a GraphStore<NS, ES, GS, EXT>,
+    ) -> Self {
+        Self {
+            node_writers,
+            edge_writer,
+            graph,
+        }
+    }
+
+    pub fn add_edge_into_layer<T: AsTime>(
+        &mut self,
+        t: T,
+        src: impl Into<VID>,
+        dst: impl Into<VID>,
+        edge: MaybeNew<ELID>,
+        props: impl IntoIterator<Item = (usize, Prop)>,
+    ) {
+        let src = src.into();
+        let dst = dst.into();
+        let e_id = edge.inner();
+        let layer = e_id.layer();
+
+        // assert!(layer > 0, "Edge must be in a layer greater than 0");
+
+        let (_, src_pos) = self.graph.nodes().resolve_pos(src);
+        let (_, dst_pos) = self.graph.nodes().resolve_pos(dst);
+
+        let edge_max_page_len = self
+            .edge_writer
+            .writer
+            .get_or_create_layer(layer)
+            .max_page_len();
+        let (_, edge_pos) = resolve_pos(e_id.edge, edge_max_page_len);
+
+        self.edge_writer
+            .add_edge(t, edge_pos, src, dst, props, layer);
+
+        let edge_id = edge.inner();
+
+        if edge.is_new()
+            || self
+                .node_writers
+                .get_mut_src()
+                .get_out_edge(src_pos, dst, edge_id.layer())
+                .is_none()
+        {
+            self.node_writers
+                .get_mut_src()
+                .add_outbound_edge(Some(t), src_pos, dst, edge_id);
+            self.node_writers
+                .get_mut_dst()
+                .add_inbound_edge(Some(t), dst_pos, src, edge_id);
+        }
+
+        self.node_writers
+            .get_mut_src()
+            .update_timestamp(t, src_pos, e_id);
+        self.node_writers
+            .get_mut_dst()
+            .update_timestamp(t, dst_pos, e_id);
+    }
+
+    pub fn delete_edge_from_layer<T: AsTime>(
+        &mut self,
+        t: T,
+        src: impl Into<VID>,
+        dst: impl Into<VID>,
+        edge: MaybeNew<ELID>,
+    ) {
+        let src = src.into();
+        let dst = dst.into();
+        let e_id = edge.inner();
+        let layer = e_id.layer();
+
+        // assert!(layer > 0, "Edge must be in a layer greater than 0");
+
+        let (_, src_pos) = self.graph.nodes().resolve_pos(src);
+        let (_, dst_pos) = self.graph.nodes().resolve_pos(dst);
+
+        let edge_max_page_len = self
+            .edge_writer
+            .writer
+            .get_or_create_layer(layer)
+            .max_page_len();
+        let (_, edge_pos) = resolve_pos(e_id.edge, edge_max_page_len);
+
+        self.edge_writer.delete_edge(t, edge_pos, src, dst, layer);
+
+        let edge_id = edge.inner();
+
+        if edge_id.layer() > STATIC_GRAPH_LAYER_ID {
+            if edge.is_new()
+                || self
+                    .node_writers
+                    .get_mut_src()
+                    .get_out_edge(src_pos, dst, edge_id.layer())
+                    .is_none()
+            {
+                self.node_writers
+                    .get_mut_src()
+                    .add_outbound_edge(Some(t), src_pos, dst, edge_id);
+
+                self.node_writers
+                    .get_mut_dst()
+                    .add_inbound_edge(Some(t), dst_pos, src, edge_id);
+            }
+
+            self.node_writers
+                .get_mut_src()
+                .update_deletion_time(t, src_pos, e_id);
+
+            self.node_writers
+                .get_mut_dst()
+                .update_deletion_time(t, dst_pos, e_id);
+        }
+    }
+
+    pub fn add_static_edge(&mut self, src: impl Into<VID>, dst: impl Into<VID>) -> MaybeNew<EID> {
+        let src = src.into();
+        let dst = dst.into();
+
+        let (_, src_pos) = self.graph.nodes().resolve_pos(src);
+        let (_, dst_pos) = self.graph.nodes().resolve_pos(dst);
+
+        let existing_eid =
+            self.node_writers
+                .get_mut_src()
+                .get_out_edge(src_pos, dst, STATIC_GRAPH_LAYER_ID);
+
+        // Edge already exists, so no need to add it again.
+        if let Some(eid) = existing_eid {
+            return MaybeNew::Existing(eid);
+        }
+
+        let edge_pos = None;
+        let already_counted = false;
+        let edge_pos = self
+            .edge_writer
+            .add_static_edge(edge_pos, src, dst, already_counted);
+        let edge_id = edge_pos.as_eid(
+            self.edge_writer.segment_id(),
+            self.graph.edges().max_page_len(),
+        );
+
+        self.node_writers
+            .get_mut_src()
+            .add_static_outbound_edge(src_pos, dst, edge_id);
+        self.node_writers
+            .get_mut_dst()
+            .add_static_inbound_edge(dst_pos, src, edge_id);
+
+        MaybeNew::New(edge_id)
+    }
+
+    pub fn node_writers(
+        &mut self,
+    ) -> &mut NodeWriters<'a, RwLockWriteGuard<'a, MemNodeSegment>, NS> {
+        &mut self.node_writers
+    }
+
+    pub fn set_lsn(&mut self, lsn: LSN) {
+        self.node_writers.set_lsn(lsn);
+        self.edge_writer.set_lsn(lsn);
+    }
+}
diff --git a/db4-storage/src/pages/test_utils/fixtures.rs b/db4-storage/src/pages/test_utils/fixtures.rs
new file mode 100644
index 0000000000..bd650cdf26
--- /dev/null
+++ b/db4-storage/src/pages/test_utils/fixtures.rs
@@ -0,0 +1,167 @@
+use super::props::{make_props, prop_type};
+use proptest::{collection, prelude::*};
+use raphtory_api::core::entities::{LayerId, properties::prop::Prop};
+use raphtory_core::entities::VID;
+use std::{collections::HashMap, ops::Range};
+
+pub type AddEdge = (
+    VID,
+    VID,
+    i64,
+    Vec<(String, Prop)>,
+    Vec<(String, Prop)>,
+    Option<&'static str>,
+);
+
+#[derive(Debug)]
+pub struct NodeFixture {
+    pub temp_props: Vec<(VID, i64, Vec<(String, Prop)>)>,
+    pub const_props: Vec<(VID, Vec<(String, Prop)>)>,
+}
+
+#[derive(Debug)]
+pub struct Fixture {
+    pub edges: Vec<AddEdge>,
+    pub const_props: HashMap<(VID, VID), Vec<(String, Prop)>>,
+}
+
+impl From<Vec<AddEdge>> for Fixture {
+    fn from(edges: Vec<AddEdge>) -> Self {
+        let mut const_props = HashMap::new();
+        for (src, dst, _, _, c_props, _) in &edges {
+            for (k, v) in c_props {
+                const_props
+                    .entry((*src, *dst))
+                    .or_insert_with(|| vec![])
+                    .push((k.clone(), v.clone()));
+            }
+        }
+        const_props.iter_mut().for_each(|(_, v)| {
+            v.sort_by(|a, b| a.0.cmp(&b.0));
+            v.dedup_by(|a, b| a.0 == b.0);
+        });
+        Self { edges, const_props }
+    }
+}
+
+pub fn make_edges(num_edges: usize, num_nodes: usize) -> impl Strategy<Value = Fixture> {
+    assert!(num_edges > 0);
+    assert!(num_nodes > 0);
+    (1..=num_edges, 1..=num_nodes)
+        .prop_flat_map(|(len, num_nodes)| build_raw_edges(len, num_nodes))
+        .prop_map(|edges| edges.into())
+}
+
+pub type PropsFixture = (Vec<(i64, Vec<(String, Prop)>)>, Vec<(String, Prop)>);
+
+pub fn make_props_strat(num_props: Range<usize>) -> impl Strategy<Value = PropsFixture> {
+    let schema = proptest::collection::hash_map(
+        (0i32..10).prop_map(|i| i.to_string()),
+        prop_type(),
+        num_props.clone(),
+    );
+
+    schema.prop_flat_map(move |schema| {
+        let (t_props, c_props) = make_props(&schema);
+        let temp_props = proptest::collection::vec((0i64..1000, t_props), num_props.clone());
+
+        temp_props.prop_flat_map(move |temp_props| {
+            c_props
+                .clone()
+                .prop_map(move |const_props| (temp_props.clone(), const_props))
+        })
+    })
+}
+
+pub fn make_nodes(num_nodes: usize) -> impl Strategy<Value = NodeFixture> {
+    assert!(num_nodes > 0);
+    let schema =
+        proptest::collection::hash_map((0i32..10).prop_map(|i| i.to_string()), prop_type(), 0..30);
+
+    schema.prop_flat_map(move |schema| {
+        let (t_props, c_props) = make_props(&schema);
+        let temp_props = proptest::collection::vec(
+            ((0..num_nodes).prop_map(VID), 0i64..1000, t_props),
+            1..=num_nodes,
+        );
+
+        let const_props =
+            proptest::collection::vec(((0..num_nodes).prop_map(VID), c_props), 1..=num_nodes);
+
+        let const_props = const_props.prop_map(|mut nodes_with_const| {
+            nodes_with_const.sort_by(|(vid, _), (vid2, _)| vid.cmp(vid2));
+            nodes_with_const
+                .chunk_by(|(vid, _), (vid2, _)| *vid == *vid2)
+                .map(|stuff| {
+                    let props = stuff
+                        .iter()
+                        .flat_map(|(_, values)| values.clone())
+                        .collect::<HashMap<_, _>>();
+                    let vid = stuff[0].0;
+                    (vid, props.into_iter().collect::<Vec<_>>())
+                })
+                .collect()
+        });
+
+        (temp_props, const_props).prop_map(|(temp_props, const_props)| NodeFixture {
+            temp_props,
+            const_props,
+        })
+    })
+}
+
+pub fn edges_strat(size: usize) -> impl Strategy<Value = Vec<(VID, VID)>> {
+    (1..=size).prop_flat_map(|num_nodes| {
+        let num_edges = 0..(num_nodes * num_nodes);
+        let srcs = (0usize..num_nodes).prop_map(VID);
+        let dsts = (0usize..num_nodes).prop_map(VID);
+        num_edges.prop_flat_map(move |num_edges| {
+            collection::vec((srcs.clone(), dsts.clone()), num_edges)
+        })
+    })
+}
+
+pub fn edges_strat_with_layers(
+    size: usize,
+) -> impl Strategy<Value = Vec<(VID, VID, Option<LayerId>)>> {
+    const MAX_LAYERS: usize = 16;
+
+    (1..=size).prop_flat_map(|num_nodes| {
+        let num_edges = 0..(num_nodes * num_nodes);
+        let srcs = (0usize..num_nodes).prop_map(VID);
+        let dsts = (0usize..num_nodes).prop_map(VID);
+        let layer_ids = (1usize..MAX_LAYERS).prop_map(|id| Some(LayerId(id)));
+
+        num_edges.prop_flat_map(move |num_edges| {
+            collection::vec((srcs.clone(), dsts.clone(), layer_ids.clone()), num_edges)
+        })
+    })
+}
+
+pub type EdgeValues = (
+    VID,
+    VID,
+    i64,
+    Vec<(String, Prop)>,
+    Vec<(String, Prop)>,
+    Option<&'static str>,
+);
+
+pub fn build_raw_edges(len: usize, num_nodes: usize) -> impl Strategy<Value = Vec<EdgeValues>> {
+    proptest::collection::hash_map((0i32..1000).prop_map(|i| i.to_string()), prop_type(), 0..20)
+        .prop_flat_map(move |schema| {
+            let (t_props, c_props) = make_props(&schema);
+
+            proptest::collection::vec(
+                (
+                    (0..num_nodes).prop_map(VID),
+                    (0..num_nodes).prop_map(VID),
+                    0i64..(num_nodes as i64 * 5),
+                    t_props,
+                    c_props,
+                    proptest::sample::select(vec![Some("a"), Some("b"), None]),
+                ),
+                1..=len,
+            )
+        })
+}
diff --git a/db4-storage/src/pages/test_utils/mod.rs b/db4-storage/src/pages/test_utils/mod.rs
new file mode 100644
index 0000000000..e36d69e73b
--- /dev/null
+++ b/db4-storage/src/pages/test_utils/mod.rs
@@ -0,0 +1,5 @@
+mod fixtures;
+mod props;
+
+pub use fixtures::*;
+pub use props::*;
diff --git a/db4-storage/src/pages/test_utils/props.rs b/db4-storage/src/pages/test_utils/props.rs
new file mode 100644
index 0000000000..51153167a8
--- /dev/null
+++ b/db4-storage/src/pages/test_utils/props.rs
@@ -0,0 +1,136 @@
+use bigdecimal::BigDecimal;
+use chrono::{DateTime, NaiveDateTime, Utc};
+use itertools::Itertools;
+use proptest::prelude::*;
+use raphtory_api::core::entities::properties::prop::{DECIMAL_MAX, Prop, PropArray, PropType};
+use std::collections::HashMap;
+
+pub fn prop_type() -> impl Strategy<Value = PropType> {
+    let leaf = proptest::sample::select(&[
+        PropType::Str,
+        PropType::I64,
+        PropType::F64,
+        PropType::F32,
+        PropType::I32,
+        PropType::U8,
+        PropType::Bool,
+        PropType::DTime,
+        PropType::NDTime,
+        PropType::Decimal { scale: 7 }, // decimal breaks the tests because of polars-parquet
+    ]);
+
+    leaf.prop_recursive(3, 10, 10, |inner| {
+        let keys = (0..1_000_000).prop_map(|i| format!("k_{i}"));
+        let dict =
+            proptest::collection::hash_map(keys, inner.clone(), 1..10).prop_map(PropType::map);
+        let list = inner
+            .clone()
+            .prop_map(|p_type| PropType::List(Box::new(p_type)));
+        prop_oneof![inner, list, dict]
+    })
+}
+
+pub fn make_props(
+    schema: &HashMap<String, PropType>,
+) -> (
+    BoxedStrategy<Vec<(String, Prop)>>,
+    BoxedStrategy<Vec<(String, Prop)>>,
+) {
+    let mut iter = schema.iter();
+
+    // split in half, one temporal one constant
+    let t_prop_s = (&mut iter)
+        .take(schema.len() / 2)
+        .map(|(k, v)| (k.clone(), v.clone()))
+        .collect::<Vec<_>>();
+    let c_prop_s = iter
+        .map(|(k, v)| (k.clone(), v.clone()))
+        .collect::<Vec<_>>();
+
+    let num_tprops = t_prop_s.len();
+    let num_cprops = c_prop_s.len();
+
+    let t_props = proptest::sample::subsequence(t_prop_s, 0..=num_tprops).prop_flat_map(|schema| {
+        schema
+            .into_iter()
+            .map(|(k, v)| prop(&v).prop_map(move |prop| (k.clone(), prop)))
+            .collect::<Vec<_>>()
+    });
+    let c_props = proptest::sample::subsequence(c_prop_s, 0..=num_cprops).prop_flat_map(|schema| {
+        schema
+            .into_iter()
+            .map(|(k, v)| prop(&v).prop_map(move |prop| (k.clone(), prop)))
+            .collect::<Vec<_>>()
+    });
+    (t_props.boxed(), c_props.boxed())
+}
+
+pub(crate) fn prop(p_type: &PropType) -> impl Strategy<Value = Prop> + use<> {
+    match p_type {
+        PropType::Str => (0i32..1000).prop_map(|s| Prop::str(s.to_string())).boxed(),
+        PropType::I64 => any::<i64>().prop_map(Prop::I64).boxed(),
+        PropType::I32 => any::<i32>().prop_map(Prop::I32).boxed(),
+        PropType::F64 => any::<f64>().prop_map(Prop::F64).boxed(),
+        PropType::F32 => any::<f32>().prop_map(Prop::F32).boxed(),
+        PropType::U8 => any::<u8>().prop_map(Prop::U8).boxed(),
+        PropType::Bool => any::<bool>().prop_map(Prop::Bool).boxed(),
+        PropType::DTime => (1900..2024, 1..=12, 1..28, 0..24, 0..60, 0..60)
+            .prop_map(|(year, month, day, h, m, s)| {
+                Prop::DTime(
+                    format!(
+                        "{:04}-{:02}-{:02}T{:02}:{:02}:{:02}Z",
+                        year, month, day, h, m, s
+                    )
+                    .parse::<DateTime<Utc>>()
+                    .unwrap(),
+                )
+            })
+            .boxed(),
+        PropType::NDTime => (1970..2024, 1..=12, 1..28, 0..24, 0..60, 0..60)
+            .prop_map(|(year, month, day, h, m, s)| {
+                // 2015-09-18T23:56:04
+                Prop::NDTime(
+                    format!(
+                        "{:04}-{:02}-{:02}T{:02}:{:02}:{:02}",
+                        year, month, day, h, m, s
+                    )
+                    .parse::<NaiveDateTime>()
+                    .unwrap(),
+                )
+            })
+            .boxed(),
+        // TODO: empty lists are a type nightmare
+        PropType::List(p_type) => proptest::collection::vec(prop(p_type), 1..10)
+            .prop_map(|props| Prop::List(PropArray::Vec(props.into())))
+            .boxed(),
+        PropType::Map(p_types) => {
+            let prop_types: Vec<BoxedStrategy<(String, Prop)>> = p_types
+                .iter()
+                .map(|(a, b)| (a.clone(), b.clone()))
+                .collect::<Vec<_>>()
+                .into_iter()
+                .map(|(name, p_type)| {
+                    prop(&p_type)
+                        .prop_map(move |prop| (name.clone(), prop.clone()))
+                        .boxed()
+                })
+                .collect_vec();
+
+            let props = proptest::sample::select(prop_types).prop_flat_map(|prop| prop);
+
+            proptest::collection::vec(props, 1..10)
+                .prop_map(Prop::map)
+                .boxed()
+        }
+        PropType::Decimal { scale } => {
+            let scale = *scale;
+            let dec_max = DECIMAL_MAX;
+            ((scale as i128)..dec_max)
+                .prop_map(move |int| Prop::Decimal(BigDecimal::new(int.into(), scale)))
+                .boxed()
+        }
+        pt => {
+            panic!("Unsupported prop type: {:?}", pt);
+        }
+    }
+}
diff --git a/db4-storage/src/persist/config.rs b/db4-storage/src/persist/config.rs
new file mode 100644
index 0000000000..80435eaa16
--- /dev/null
+++ b/db4-storage/src/persist/config.rs
@@ -0,0 +1,167 @@
+use crate::error::StorageError;
+use clap::{
+    Args, Command,
+    error::{ContextKind, ContextValue},
+};
+use serde::{Deserialize, Serialize, de::DeserializeOwned};
+use std::{iter, path::Path};
+use tracing::error;
+
+pub const DEFAULT_MAX_PAGE_LEN_NODES: u32 = 131_072; // 2^17
+pub const DEFAULT_MAX_PAGE_LEN_EDGES: u32 = 1_048_576; // 2^20
+
+const CONFIG_FILE_NAME: &str = "config.json";
+
+pub trait ConfigOps: Serialize + DeserializeOwned + Args + Sized {
+    fn max_node_page_len(&self) -> u32;
+
+    fn max_edge_page_len(&self) -> u32;
+
+    fn node_types(&self) -> &[String];
+
+    fn with_max_node_page_len(self, page_len: u32) -> Self;
+
+    fn with_max_edge_page_len(self, page_len: u32) -> Self;
+
+    fn with_node_types(&self, node_types: impl IntoIterator<Item = impl AsRef<str>>) -> Self;
+
+    fn load_from_dir(dir: &Path) -> Result<Self, StorageError> {
+        let config_file = dir.join(CONFIG_FILE_NAME);
+        let config_file = std::fs::File::open(config_file)?;
+        let config = serde_json::from_reader(config_file)?;
+        Ok(config)
+    }
+
+    fn save_to_dir(&self, dir: &Path) -> Result<(), StorageError> {
+        let config_file = dir.join(CONFIG_FILE_NAME);
+        let config_file = std::fs::File::create(&config_file)?;
+        serde_json::to_writer_pretty(config_file, self)?;
+        Ok(())
+    }
+
+    fn update(&mut self, new: Self);
+}
+
+#[derive(Debug, Copy, Clone, Serialize, Deserialize, Args)]
+#[serde(default)]
+pub struct BaseConfig {
+    #[arg(long, default_value_t=DEFAULT_MAX_PAGE_LEN_NODES, env="RAPHTORY_MAX_NODE_PAGE_LEN")]
+    max_node_page_len: u32,
+
+    #[arg(long, default_value_t=DEFAULT_MAX_PAGE_LEN_EDGES, env="RAPHTORY_MAX_EDGE_PAGE_LEN")]
+    max_edge_page_len: u32,
+}
+
+pub trait ClapDefault: Args {
+    fn clap_default() -> Self;
+}
+
+fn display_error(err: &clap::Error, cm: &Command) -> String {
+    if let Some(ContextValue::String(variable)) = err.get(ContextKind::InvalidArg) {
+        if let Some(ContextValue::String(value)) = err.get(ContextKind::InvalidValue) {
+            if let Some(arg) = cm.get_arguments().find(|arg| {
+                arg.get_long().is_some_and(|long| {
+                    variable.starts_with(&format!("--{long}"))
+                        || arg
+                            .get_short()
+                            .is_some_and(|short| variable.starts_with(&format!("-{short}")))
+                })
+            }) {
+                if let Some(env) = arg.get_env() {
+                    let id = arg.get_id();
+                    let env = env.display();
+                    return format!("Invalid value from environment for '{id}': '{env}={value}'");
+                }
+            }
+        }
+    }
+    err.to_string()
+}
+
+impl<T: Args + Default> ClapDefault for T {
+    fn clap_default() -> Self {
+        let cm = Self::augment_args(Command::default().no_binary_name(true));
+        cm.clone()
+            .try_get_matches_from(iter::empty::<String>())
+            .and_then(|mut matches| Self::from_arg_matches_mut(&mut matches))
+            .unwrap_or_else(|err| {
+                error!(
+                    "{}, ignoring environment variables.",
+                    display_error(&err, &cm)
+                );
+                // unset environment variables and try again
+                cm.mut_args(|arg| arg.env(None))
+                    .try_get_matches_from(iter::empty::<String>())
+                    .and_then(|mut matches| Self::from_arg_matches_mut(&mut matches))
+                    .expect("Reading defaults without environment variables should not fail.")
+            })
+    }
+}
+
+impl Default for BaseConfig {
+    fn default() -> Self {
+        Self::clap_default()
+    }
+}
+
+impl BaseConfig {
+    pub fn new(max_node_page_len: u32, max_edge_page_len: u32) -> Self {
+        Self {
+            max_node_page_len,
+            max_edge_page_len,
+        }
+    }
+}
+
+impl ConfigOps for BaseConfig {
+    fn max_node_page_len(&self) -> u32 {
+        self.max_node_page_len
+    }
+
+    fn max_edge_page_len(&self) -> u32 {
+        self.max_edge_page_len
+    }
+
+    fn with_max_node_page_len(mut self, page_len: u32) -> Self {
+        self.max_node_page_len = page_len;
+        self
+    }
+
+    fn with_max_edge_page_len(mut self, page_len: u32) -> Self {
+        self.max_edge_page_len = page_len;
+        self
+    }
+
+    fn node_types(&self) -> &[String] {
+        &[]
+    }
+
+    fn with_node_types(&self, _node_types: impl IntoIterator<Item = impl AsRef<str>>) -> Self {
+        *self
+    }
+
+    fn update(&mut self, _new: Self) {
+        // cannot update page lengths for an existing graph
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::persist::config::{
+        BaseConfig, DEFAULT_MAX_PAGE_LEN_EDGES, DEFAULT_MAX_PAGE_LEN_NODES,
+    };
+
+    #[test_log::test]
+    fn test_default() {
+        let default = BaseConfig::default();
+        assert_eq!(default.max_edge_page_len, DEFAULT_MAX_PAGE_LEN_EDGES);
+        assert_eq!(default.max_node_page_len, DEFAULT_MAX_PAGE_LEN_NODES);
+    }
+
+    #[test]
+    fn test_deserialize() {
+        let default: BaseConfig = serde_json::from_str("{}").unwrap();
+        assert_eq!(default.max_edge_page_len, DEFAULT_MAX_PAGE_LEN_EDGES);
+        assert_eq!(default.max_node_page_len, DEFAULT_MAX_PAGE_LEN_NODES);
+    }
+}
diff --git a/db4-storage/src/persist/control_file.rs b/db4-storage/src/persist/control_file.rs
new file mode 100644
index 0000000000..9c8c942884
--- /dev/null
+++ b/db4-storage/src/persist/control_file.rs
@@ -0,0 +1,53 @@
+use crate::{error::StorageError, wal::LSN};
+use serde::{Deserialize, Serialize};
+use std::path::Path;
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+pub enum DBState {
+    Running,
+    Shutdown,
+    CrashRecovery,
+    NotSupported,
+}
+
+// Starting value for `last_checkpoint` in the control file.
+pub const LAST_CHECKPOINT_INIT: LSN = 0;
+
+pub trait ControlFileOps: Sized {
+    fn load(dir: &Path) -> Result<Self, StorageError>;
+
+    fn save(&self) -> Result<(), StorageError>;
+
+    fn db_state(&self) -> DBState;
+
+    fn last_checkpoint(&self) -> LSN;
+
+    fn set_db_state(&self, state: DBState);
+
+    fn set_checkpoint(&self, lsn: LSN);
+}
+
+#[derive(Debug, Clone)]
+pub struct NoControlFile;
+
+impl ControlFileOps for NoControlFile {
+    fn load(_dir: &Path) -> Result<Self, StorageError> {
+        Ok(NoControlFile)
+    }
+
+    fn save(&self) -> Result<(), StorageError> {
+        Ok(())
+    }
+
+    fn db_state(&self) -> DBState {
+        DBState::NotSupported
+    }
+
+    fn last_checkpoint(&self) -> LSN {
+        0
+    }
+
+    fn set_db_state(&self, state: DBState) {}
+
+    fn set_checkpoint(&self, lsn: LSN) {}
+}
diff --git a/db4-storage/src/persist/mod.rs b/db4-storage/src/persist/mod.rs
new file mode 100644
index 0000000000..7609d5b63e
--- /dev/null
+++ b/db4-storage/src/persist/mod.rs
@@ -0,0 +1,3 @@
+pub mod config;
+pub mod control_file;
+pub mod strategy;
diff --git a/db4-storage/src/persist/strategy.rs b/db4-storage/src/persist/strategy.rs
new file mode 100644
index 0000000000..f733365aab
--- /dev/null
+++ b/db4-storage/src/persist/strategy.rs
@@ -0,0 +1,173 @@
+use crate::{
+    api::{edges::EdgeSegmentOps, graph_props::GraphPropSegmentOps, nodes::NodeSegmentOps},
+    error::StorageError,
+    persist::{
+        config::{BaseConfig, ConfigOps},
+        control_file::{ControlFileOps, NoControlFile},
+    },
+    segments::{
+        edge::segment::{EdgeSegmentView, MemEdgeSegment},
+        graph_prop::{GraphPropSegmentView, segment::MemGraphPropSegment},
+        node::segment::{MemNodeSegment, NodeSegmentView},
+    },
+    wal::{GraphWalOps, WalOps, no_wal::NoWal},
+};
+use std::{
+    fmt::Debug,
+    ops::DerefMut,
+    path::Path,
+    sync::{
+        Arc,
+        atomic::{AtomicUsize, Ordering},
+    },
+};
+
+pub trait PersistenceStrategy: Debug + Clone + Send + Sync + 'static {
+    type NS: NodeSegmentOps;
+    type ES: EdgeSegmentOps;
+    type GS: GraphPropSegmentOps;
+    type Wal: WalOps + GraphWalOps;
+    type Config: ConfigOps;
+    type ControlFile: ControlFileOps;
+
+    fn new(config: Self::Config, graph_dir: Option<&Path>) -> Result<Self, StorageError>;
+
+    fn load(graph_dir: &Path) -> Result<Self, StorageError>;
+
+    fn load_with_config(graph_dir: &Path, config: Self::Config) -> Result<Self, StorageError>;
+
+    fn config(&self) -> &Self::Config;
+
+    fn config_mut(&mut self) -> &mut Self::Config;
+
+    fn wal(&self) -> &Self::Wal;
+
+    fn control_file(&self) -> &Self::ControlFile;
+
+    /// Called after every write and checks memory limits to decide if a flush is needed
+    fn persist_node_segment<MP: DerefMut<Target = MemNodeSegment>>(
+        &self,
+        node_segment: &Self::NS,
+        writer: MP,
+    ) where
+        Self: Sized;
+
+    /// Called after every write and checks memory limits to decide if a flush is needed
+    fn persist_edge_segment<MP: DerefMut<Target = MemEdgeSegment>>(
+        &self,
+        edge_segment: &Self::ES,
+        writer: MP,
+    ) where
+        Self: Sized;
+
+    fn persist_graph_prop_segment<MP: DerefMut<Target = MemGraphPropSegment>>(
+        &self,
+        graph_prop_segment: &Self::GS,
+        writer: MP,
+    ) where
+        Self: Sized;
+
+    /// Indicates whether the strategy persists to disk or not.
+    fn disk_storage_enabled() -> bool;
+
+    /// Estimated global memory used
+    fn memory_tracker(&self) -> &Arc<AtomicUsize>;
+
+    fn estimated_size(&self) -> usize {
+        self.memory_tracker().load(Ordering::Relaxed)
+    }
+
+    /// Called by bulk loaders to decide if a global flush should be triggered
+    fn should_flush(&self) -> bool;
+    fn should_pause(&self) -> bool;
+}
+
+#[derive(Debug, Clone)]
+pub struct NoOpStrategy {
+    config: BaseConfig,
+    memory_tracker: Arc<AtomicUsize>,
+    wal: NoWal,
+    control_file: NoControlFile,
+}
+
+impl PersistenceStrategy for NoOpStrategy {
+    type NS = NodeSegmentView<Self>;
+    type ES = EdgeSegmentView<Self>;
+    type GS = GraphPropSegmentView<Self>;
+    type Wal = NoWal;
+    type Config = BaseConfig;
+    type ControlFile = NoControlFile;
+
+    fn new(config: BaseConfig, _graph_dir: Option<&Path>) -> Result<Self, StorageError> {
+        Ok(Self {
+            config,
+            wal: NoWal,
+            control_file: NoControlFile,
+            memory_tracker: Arc::new(AtomicUsize::new(0)),
+        })
+    }
+
+    fn load(_graph_dir: &Path) -> Result<Self, StorageError> {
+        Err(StorageError::DiskStorageNotSupported)
+    }
+
+    fn load_with_config(_graph_dir: &Path, _config: Self::Config) -> Result<Self, StorageError> {
+        Err(StorageError::DiskStorageNotSupported)
+    }
+
+    fn config(&self) -> &Self::Config {
+        &self.config
+    }
+
+    fn config_mut(&mut self) -> &mut Self::Config {
+        &mut self.config
+    }
+
+    fn wal(&self) -> &Self::Wal {
+        &self.wal
+    }
+
+    fn control_file(&self) -> &Self::ControlFile {
+        &self.control_file
+    }
+
+    fn persist_node_segment<MP: DerefMut<Target = MemNodeSegment>>(
+        &self,
+        _node_page: &Self::NS,
+        _writer: MP,
+    ) {
+        // No operation
+    }
+
+    fn persist_edge_segment<MP: DerefMut<Target = MemEdgeSegment>>(
+        &self,
+        _edge_page: &Self::ES,
+        _writer: MP,
+    ) {
+        // No operation
+    }
+
+    fn persist_graph_prop_segment<MP: DerefMut<Target = MemGraphPropSegment>>(
+        &self,
+        _graph_segment: &Self::GS,
+        _writer: MP,
+    ) {
+        // No operation
+    }
+
+    fn disk_storage_enabled() -> bool {
+        false
+    }
+
+    fn memory_tracker(&self) -> &Arc<AtomicUsize> {
+        &self.memory_tracker
+    }
+
+    fn should_flush(&self) -> bool {
+        false
+    }
+
+    fn should_pause(&self) -> bool {
+        false
+    }
+}
diff --git a/db4-storage/src/properties/mod.rs b/db4-storage/src/properties/mod.rs
new file mode 100644
index 0000000000..39b361b3ae
--- /dev/null
+++ b/db4-storage/src/properties/mod.rs
@@ -0,0 +1,383 @@
+use crate::error::StorageError;
+use arrow_array::{
+    ArrayRef, BooleanArray, Decimal128Array, Float32Array, Float64Array, Int32Array, Int64Array,
+    StringViewArray, TimestampMillisecondArray, UInt8Array, UInt16Array, UInt32Array, UInt64Array,
+};
+use arrow_schema::DECIMAL128_MAX_PRECISION;
+use bigdecimal::ToPrimitive;
+use raphtory_api::core::entities::properties::{
+    meta::PropMapper,
+    prop::{
+        AsPropRef, Prop, PropRef, PropType, SerdeArrowList, SerdeArrowMap,
+        arrow_dtype_from_prop_type, list_array_from_props, struct_array_from_props,
+    },
+};
+use raphtory_core::{
+    entities::{
+        ELID,
+        properties::{props::MetadataError, tcell::TCell, tprop::TPropCell},
+    },
+    storage::{PropColumn, TColumns, timeindex::EventTime},
+};
+use std::sync::Arc;
+
+pub mod props_meta_writer;
+
+#[derive(Debug, Default)]
+pub struct Properties {
+    c_properties: Vec<PropColumn>,
+
+    additions: Vec<TCell<ELID>>,
+    deletions: Vec<TCell<ELID>>,
+    times_from_props: Vec<TCell<Option<usize>>>,
+
+    t_properties: TColumns,
+    earliest: Option<EventTime>,
+    latest: Option<EventTime>,
+    has_additions: bool,
+    has_properties: bool,
+    has_deletions: bool,
+    pub additions_count: usize,
+}
+
+pub(crate) struct PropMutEntry<'a> {
+    row: usize,
+    properties: &'a mut Properties,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct PropEntry<'a> {
+    row: usize,
+    properties: &'a Properties,
+}
+
+impl Properties {
+    pub fn est_size(&self) -> usize {
+        self.t_properties.len() + self.c_properties.len()
+    }
+
+    pub(crate) fn get_mut_entry(&mut self, row: usize) -> PropMutEntry<'_> {
+        PropMutEntry {
+            row,
+            properties: self,
+        }
+    }
+
+    pub(crate) fn get_entry(&self, row: usize) -> PropEntry<'_> {
+        PropEntry {
+            row,
+            properties: self,
+        }
+    }
+
+    pub fn earliest(&self) -> Option<EventTime> {
+        self.earliest
+    }
+
+    pub fn latest(&self) -> Option<EventTime> {
+        self.latest
+    }
+
+    pub fn t_column(&self, prop_id: usize) -> Option<&PropColumn> {
+        self.t_properties.get(prop_id)
+    }
+
+    pub fn t_column_mut(&mut self, prop_id: usize) -> Option<&mut PropColumn> {
+        self.t_properties.get_mut(prop_id)
+    }
+
+    pub fn c_column(&self, prop_id: usize) -> Option<&PropColumn> {
+        self.c_properties.get(prop_id)
+    }
+
+    pub fn num_t_columns(&self) -> usize {
+        self.t_properties.num_columns()
+    }
+
+    pub fn num_c_columns(&self) -> usize {
+        self.c_properties.len()
+    }
+
+    pub(crate) fn additions(&self, row: usize) -> Option<&TCell<ELID>> {
+        self.additions.get(row)
+    }
+
+    pub(crate) fn deletions(&self, row: usize) -> Option<&TCell<ELID>> {
+        self.deletions.get(row)
+    }
+
+    pub(crate) fn times_from_props(&self, row: usize) -> Option<&TCell<Option<usize>>> {
+        self.times_from_props.get(row)
+    }
+
+    pub fn has_properties(&self) -> bool {
+        self.has_properties
+    }
+
+    pub fn set_has_properties(&mut self) {
+        self.has_properties = true
+    }
+
+    pub fn has_additions(&self) -> bool {
+        self.has_additions
+    }
+
+    pub fn has_deletions(&self) -> bool {
+        self.has_deletions
+    }
+
+    pub(crate) fn column_as_array(
+        &self,
+        column: &PropColumn,
+        col_id: usize,
+        meta: &PropMapper,
+        indices: impl Iterator<Item = usize>,
+    ) -> Option<ArrayRef> {
+        match column {
+            PropColumn::Empty(_) => None,
+            PropColumn::U32(lazy_vec) => Some(Arc::new(UInt32Array::from_iter(
+                indices.map(|i| lazy_vec.get_opt(i).copied()),
+            ))),
+            PropColumn::Bool(lazy_vec) => Some(Arc::new(BooleanArray::from_iter(
+                indices.map(|i| lazy_vec.get_opt(i).copied()),
+            ))),
+            PropColumn::U8(lazy_vec) => Some(Arc::new(UInt8Array::from_iter(
+                indices.map(|i| lazy_vec.get_opt(i).copied()),
+            ))),
+            PropColumn::U16(lazy_vec) => Some(Arc::new(UInt16Array::from_iter(
+                indices.map(|i| lazy_vec.get_opt(i).copied()),
+            ))),
+            PropColumn::U64(lazy_vec) => Some(Arc::new(UInt64Array::from_iter(
+                indices.map(|i| lazy_vec.get_opt(i).copied()),
+            ))),
+            PropColumn::I32(lazy_vec) => Some(Arc::new(Int32Array::from_iter(
+                indices.map(|i| lazy_vec.get_opt(i).copied()),
+            ))),
+            PropColumn::I64(lazy_vec) => Some(Arc::new(Int64Array::from_iter(
+                indices.map(|i| lazy_vec.get_opt(i).copied()),
+            ))),
+            PropColumn::F32(lazy_vec) => Some(Arc::new(Float32Array::from_iter(
+                indices.map(|i| lazy_vec.get_opt(i).copied()),
+            ))),
+            PropColumn::F64(lazy_vec) => Some(Arc::new(Float64Array::from_iter(
+                indices.map(|i| lazy_vec.get_opt(i).copied()),
+            ))),
+            PropColumn::Str(lazy_vec) => Some(Arc::new(StringViewArray::from_iter(
+                indices.map(|i| lazy_vec.get_opt(i)),
+            ))),
+            PropColumn::DTime(lazy_vec) => Some(Arc::new(
+                TimestampMillisecondArray::from_iter(
+                    indices.map(|i| lazy_vec.get_opt(i).copied().map(|dt| dt.timestamp_millis())),
+                )
+                .with_timezone("UTC"),
+            )),
+            PropColumn::NDTime(lazy_vec) => Some(Arc::new(TimestampMillisecondArray::from_iter(
+                indices.map(|i| {
+                    lazy_vec
+                        .get_opt(i)
+                        .copied()
+                        .map(|dt| dt.and_utc().timestamp_millis())
+                }),
+            ))),
+            PropColumn::Decimal(lazy_vec) => {
+                let scale = meta
+                    .get_dtype(col_id)
+                    .and_then(|dtype| match dtype {
+                        PropType::Decimal { scale } => Some(scale as i8),
+                        _ => None,
+                    })
+                    .unwrap();
+                Some(Arc::new(
+                    Decimal128Array::from_iter(indices.map(|i| {
+                        lazy_vec.get_opt(i).and_then(|bd| {
+                            let (num, _) = bd.as_bigint_and_scale();
+                            num.to_i128()
+                        })
+                    }))
+                    .with_precision_and_scale(DECIMAL128_MAX_PRECISION, scale)
+                    .unwrap(),
+                ))
+            }
+            PropColumn::Map(lazy_vec) => {
+                let dt = meta
+                    .get_dtype(col_id)
+                    .as_ref()
+                    .map(arrow_dtype_from_prop_type)?;
+                let array_iter = indices
+                    .map(|i| lazy_vec.get_opt(i))
+                    .map(|e| e.map(|m| SerdeArrowMap(m)));
+
+                let struct_array = struct_array_from_props(&dt, array_iter).ok()?;
+
+                Some(Arc::new(struct_array))
+            }
+            PropColumn::List(lazy_vec) => {
+                let dt = meta
+                    .get_dtype(col_id)
+                    .as_ref()
+                    .map(arrow_dtype_from_prop_type)
+                    .unwrap();
+
+                let array_iter = indices
+                    .map(|i| lazy_vec.get_opt(i))
+                    .map(|opt_list| opt_list.map(SerdeArrowList));
+
+                let list_array = list_array_from_props(&dt, array_iter).ok()?;
+
+                Some(Arc::new(list_array))
+            }
+        }
+    }
+
+    pub fn take_t_column(
+        &self,
+        col_id: usize,
+        meta: &PropMapper,
+        indices: impl ExactSizeIterator<Item = usize>,
+    ) -> Option<ArrayRef> {
+        let column = self.t_properties.get(col_id)?;
+        self.column_as_array(column, col_id, meta, indices)
+    }
+
+    pub fn take_c_column(
+        &self,
+        col: usize,
+        meta: &PropMapper,
+        indices: impl Iterator<Item = usize>,
+    ) -> Option<ArrayRef> {
+        let column = self.c_properties.get(col)?;
+        self.column_as_array(column, col, meta, indices)
+    }
+
+    fn update_earliest_latest(&mut self, t: EventTime) {
+        self.additions_count += 1;
+        let earliest = self.earliest.get_or_insert(t);
+        if t < *earliest {
+            *earliest = t;
+        }
+        let latest = self.latest.get_or_insert(t);
+        if t > *latest {
+            *latest = t;
+        }
+    }
+
+    pub fn t_len(&self) -> usize {
+        self.t_properties.len()
+    }
+}
+
+impl<'a> PropMutEntry<'a> {
+    pub(crate) fn append_t_props<P: AsPropRef>(
+        &mut self,
+        t: EventTime,
+        props: impl IntoIterator<Item = (usize, P)>,
+    ) {
+        let t_prop_row = if let Some(t_prop_row) = self
+            .properties
+            .t_properties
+            .push(props)
+            .expect("Internal error: properties should be validated at this point")
+        {
+            t_prop_row
+        } else {
+            self.properties.t_properties.push_null()
+        };
+
+        self.ensure_times_from_props();
+        self.set_time(t, t_prop_row);
+
+        self.properties.has_properties = true;
+        self.properties.update_earliest_latest(t);
+    }
+
+    pub(crate) fn ensure_times_from_props(&mut self) {
+        if self.properties.times_from_props.len() <= self.row {
+            self.properties
+                .times_from_props
+                .resize_with(self.row + 1, Default::default);
+        }
+    }
+
+    pub(crate) fn set_time(&mut self, t: EventTime, t_prop_row: usize) {
+        let prop_timestamps = &mut self.properties.times_from_props[self.row];
+        prop_timestamps.set(t, Some(t_prop_row));
+    }
+
+    pub(crate) fn addition_timestamp(&mut self, t: EventTime, edge_id: ELID) {
+        if self.properties.additions.len() <= self.row {
+            self.properties
+                .additions
+                .resize_with(self.row + 1, Default::default);
+        }
+
+        self.properties.has_additions = true;
+        let prop_timestamps = &mut self.properties.additions[self.row];
+        prop_timestamps.set(t, edge_id);
+
+        self.properties.update_earliest_latest(t);
+    }
+
+    pub(crate) fn deletion_timestamp(&mut self, t: EventTime, edge_id: Option<ELID>) {
+        if self.properties.deletions.len() <= self.row {
+            self.properties
+                .deletions
+                .resize_with(self.row + 1, Default::default);
+        }
+
+        self.properties.has_deletions = true;
+
+        let prop_timestamps = &mut self.properties.deletions[self.row];
+        prop_timestamps.set(t, edge_id.unwrap_or_default());
+        self.properties.update_earliest_latest(t);
+    }
+
+    pub(crate) fn append_const_props<P: AsPropRef>(
+        &mut self,
+        props: impl IntoIterator<Item = (usize, P)>,
+    ) {
+        for (prop_id, prop) in props {
+            if self.properties.c_properties.len() <= prop_id {
+                self.properties
+                    .c_properties
+                    .resize_with(prop_id + 1, Default::default);
+            }
+            let const_props = &mut self.properties.c_properties[prop_id];
+            // property types should have been validated before!
+            const_props.upsert(self.row, prop.as_prop_ref()).unwrap();
+        }
+    }
+}
+
+impl<'a> PropEntry<'a> {
+    pub(crate) fn prop(self, prop_id: usize) -> Option<TPropCell<'a>> {
+        let t_cell = self.t_cell();
+        Some(TPropCell::new(t_cell, self.properties.t_column(prop_id)))
+    }
+
+    pub fn metadata(self, prop_id: usize) -> Option<Prop> {
+        self.properties.c_column(prop_id)?.get(self.row)
+    }
+
+    pub fn check_metadata(self, prop_id: usize, new_val: PropRef<'_>) -> Result<(), StorageError> {
+        if let Some(col) = self.properties.c_column(prop_id) {
+            col.check(self.row, &new_val)
+                .map_err(Into::<MetadataError>::into)?;
+        }
+
+        Ok(())
+    }
+
+    pub fn t_cell(self) -> &'a TCell<Option<usize>> {
+        self.properties
+            .times_from_props(self.row)
+            .unwrap_or(&TCell::Empty)
+    }
+
+    pub fn additions(self) -> &'a TCell<ELID> {
+        self.properties.additions(self.row).unwrap_or(&TCell::Empty)
+    }
+
+    pub fn deletions(self) -> &'a TCell<ELID> {
+        self.properties.deletions(self.row).unwrap_or(&TCell::Empty)
+    }
+}
diff --git a/db4-storage/src/properties/props_meta_writer.rs b/db4-storage/src/properties/props_meta_writer.rs
new file mode 100644
index 0000000000..2d0c23e901
--- /dev/null
+++ b/db4-storage/src/properties/props_meta_writer.rs
@@ -0,0 +1,311 @@
+use either::Either;
+use raphtory_api::core::{
+    entities::properties::{
+        meta::{LockedPropMapper, Meta, PropMapper},
+        prop::{Prop, unify_types},
+    },
+    storage::dict_mapper::MaybeNew,
+};
+
+use crate::error::StorageError;
+
+// TODO: Rename constant props to metadata
+#[derive(Debug, Clone, Copy)]
+pub enum PropType {
+    Temporal,
+    Constant,
+}
+
+pub enum PropsMetaWriter<'a, PN: AsRef<str>> {
+    Change {
+        props: Vec<PropEntry<'a, PN>>,
+        mapper: LockedPropMapper<'a>,
+        meta: &'a Meta,
+    },
+    NoChange {
+        props: Vec<(PN, usize, Prop)>,
+    },
+}
+
+pub enum PropEntry<'a, PN: AsRef<str> + 'a> {
+    Change {
+        name: PN,
+        prop_id: Option<usize>,
+        prop: Prop,
+        _phantom: &'a (),
+    },
+    NoChange(PN, usize, Prop),
+}
+
+impl<'a, PN: AsRef<str>> PropsMetaWriter<'a, PN> {
+    pub fn temporal(
+        meta: &'a Meta,
+        props: impl Iterator<Item = (PN, Prop)>,
+    ) -> Result<Self, StorageError> {
+        Self::new(meta, meta.temporal_prop_mapper(), props)
+    }
+
+    pub fn constant(
+        meta: &'a Meta,
+        props: impl Iterator<Item = (PN, Prop)>,
+    ) -> Result<Self, StorageError> {
+        Self::new(meta, meta.metadata_mapper(), props)
+    }
+
+    pub fn new(
+        meta: &'a Meta,
+        prop_mapper: &'a PropMapper,
+        props: impl Iterator<Item = (PN, Prop)>,
+    ) -> Result<Self, StorageError> {
+        let locked_meta = prop_mapper.locked();
+
+        let mut in_props = props
+            .size_hint()
+            .1
+            .map(Vec::with_capacity)
+            .unwrap_or_default();
+
+        let mut no_type_changes = true;
+
+        // See if any type unification is required while merging props
+        for (prop_name, prop) in props {
+            let dtype = prop.dtype();
+            let outcome @ (_, _, type_check) = locked_meta
+                .fast_proptype_check(prop_name.as_ref(), dtype)
+                .map(|outcome| (prop_name, prop, outcome))?;
+            let nothing_to_do = type_check.map(|x| x.is_right()).unwrap_or_default();
+
+            no_type_changes &= nothing_to_do;
+            in_props.push(outcome);
+        }
+
+        // If no type changes are required, we can just return the existing prop ids
+        if no_type_changes {
+            let props = in_props
+                .into_iter()
+                .filter_map(|(prop_name, prop, _)| {
+                    locked_meta
+                        .get_id(prop_name.as_ref())
+                        .map(|id| (prop_name, id, prop))
+                })
+                .collect();
+
+            return Ok(Self::NoChange { props });
+        }
+
+        let mut props = vec![];
+
+        for (prop_name, prop, outcome) in in_props {
+            props.push(Self::as_prop_entry(prop_name, prop, outcome));
+        }
+
+        Ok(Self::Change {
+            props,
+            mapper: locked_meta,
+            meta,
+        })
+    }
+
+    fn as_prop_entry(
+        prop_name: PN,
+        prop: Prop,
+        outcome: Option<Either<usize, usize>>,
+    ) -> PropEntry<'a, PN> {
+        match outcome {
+            Some(Either::Right(prop_id)) => PropEntry::NoChange(prop_name, prop_id, prop),
+            Some(Either::Left(prop_id)) => PropEntry::Change {
+                name: prop_name,
+                prop_id: Some(prop_id),
+                prop,
+                _phantom: &(),
+            },
+            None => {
+                // prop id doesn't exist so we grab the entry
+                PropEntry::Change {
+                    name: prop_name,
+                    prop_id: None,
+                    prop,
+                    _phantom: &(),
+                }
+            }
+        }
+    }
+
+    pub fn into_props_temporal(self) -> Result<Vec<(usize, Prop)>, StorageError> {
+        self.into_props_inner(PropType::Temporal)
+    }
+
+    /// Returns temporal prop names, prop ids and prop values, along with their MaybeNew status.
+    pub fn into_props_temporal_with_status(
+        self,
+    ) -> Result<Vec<MaybeNew<(PN, usize, Prop)>>, StorageError> {
+        self.into_props_inner_with_status(PropType::Temporal)
+    }
+
+    pub fn into_props_const(self) -> Result<Vec<(usize, Prop)>, StorageError> {
+        self.into_props_inner(PropType::Constant)
+    }
+
+    /// Returns constant prop names, prop ids and prop values, along with their MaybeNew status.
+    pub fn into_props_const_with_status(
+        self,
+    ) -> Result<Vec<MaybeNew<(PN, usize, Prop)>>, StorageError> {
+        self.into_props_inner_with_status(PropType::Constant)
+    }
+
+    pub fn into_props_inner(self, prop_type: PropType) -> Result<Vec<(usize, Prop)>, StorageError> {
+        self.into_props_inner_with_status(prop_type).map(|props| {
+            props
+                .into_iter()
+                .map(|maybe_new| {
+                    let (_, prop_id, prop) = maybe_new.inner();
+                    (prop_id, prop)
+                })
+                .collect()
+        })
+    }
+
+    pub fn into_props_inner_with_status(
+        self,
+        prop_type: PropType,
+    ) -> Result<Vec<MaybeNew<(PN, usize, Prop)>>, StorageError> {
+        match self {
+            Self::NoChange { props } => Ok(props
+                .into_iter()
+                .map(|(prop_name, prop_id, prop)| MaybeNew::Existing((prop_name, prop_id, prop)))
+                .collect()),
+            Self::Change {
+                props,
+                mapper,
+                meta,
+            } => {
+                let mut prop_with_ids = vec![];
+
+                drop(mapper);
+
+                let mut mapper = match prop_type {
+                    PropType::Temporal => meta.temporal_prop_mapper().write_locked(),
+                    PropType::Constant => meta.metadata_mapper().write_locked(),
+                };
+
+                // Revalidate prop types
+                let props = props
+                    .into_iter()
+                    .map(|entry| match entry {
+                        PropEntry::NoChange(name, _, prop) => {
+                            let new_entry = mapper
+                                .fast_proptype_check(name.as_ref(), prop.dtype())
+                                .map(|outcome| Self::as_prop_entry(name, prop, outcome))?;
+
+                            Ok(new_entry)
+                        }
+                        PropEntry::Change { name, prop, .. } => {
+                            let new_entry = mapper
+                                .fast_proptype_check(name.as_ref(), prop.dtype())
+                                .map(|outcome| Self::as_prop_entry(name, prop, outcome))?;
+
+                            Ok(new_entry)
+                        }
+                    })
+                    .collect::<Result<Vec<_>, StorageError>>()?;
+
+                for entry in props {
+                    match entry {
+                        PropEntry::NoChange(name, prop_id, prop) => {
+                            prop_with_ids.push(MaybeNew::Existing((name, prop_id, prop)));
+                        }
+                        PropEntry::Change {
+                            name,
+                            prop_id: Some(prop_id),
+                            prop,
+                            ..
+                        } => {
+                            // prop_id already exists, so we need to unify the types
+                            let new_prop_type = prop.dtype();
+                            let existing_type = mapper.get_dtype(prop_id).unwrap();
+                            let new_prop_type =
+                                unify_types(&new_prop_type, existing_type, &mut false)?;
+
+                            mapper.set_id_and_dtype(name.as_ref(), prop_id, new_prop_type);
+                            prop_with_ids.push(MaybeNew::Existing((name, prop_id, prop)));
+                        }
+                        PropEntry::Change { name, prop, .. } => {
+                            // prop_id doesn't exist, so we need to create a new one
+                            let new_prop_type = prop.dtype();
+                            let prop_id = mapper.new_id_and_dtype(name.as_ref(), new_prop_type);
+
+                            prop_with_ids.push(MaybeNew::New((name, prop_id, prop)));
+                        }
+                    }
+                }
+
+                Ok(prop_with_ids)
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use raphtory_api::core::storage::arc_str::ArcStr;
+
+    #[test]
+    fn test_props_meta_writer() {
+        let meta = Meta::default();
+        let props = vec![
+            (ArcStr::from("prop1"), Prop::U32(0)),
+            (ArcStr::from("prop2"), Prop::U32(1)),
+        ];
+        let writer = PropsMetaWriter::temporal(&meta, props.into_iter()).unwrap();
+        let props = writer.into_props_temporal().unwrap();
+        assert_eq!(props.len(), 2);
+
+        assert_eq!(props, vec![(0, Prop::U32(0)), (1, Prop::U32(1))]);
+
+        assert_eq!(meta.temporal_prop_mapper().keys().len(), 2);
+    }
+
+    #[test]
+    fn complex_props_meta_writer() {
+        let meta = Meta::default();
+        let prop_list_map = Prop::list([Prop::map([("a", 1)]), Prop::map([("b", 2f64)])]);
+        let props = vec![("a", prop_list_map.clone())];
+
+        let writer = PropsMetaWriter::temporal(&meta, props.into_iter()).unwrap();
+        let props = writer.into_props_temporal().unwrap();
+        assert_eq!(props.len(), 1);
+
+        assert_eq!(props, vec![(0, prop_list_map.clone())]);
+
+        let expected_d_type = prop_list_map.dtype();
+
+        assert_eq!(
+            meta.temporal_prop_mapper().d_types().first().unwrap(),
+            &expected_d_type
+        );
+    }
+
+    #[test]
+    fn test_fail_typecheck() {
+        let meta = Meta::default();
+        let prop1 = Prop::U32(0);
+        let prop2 = Prop::U64(1);
+
+        let writer =
+            PropsMetaWriter::temporal(&meta, vec![(ArcStr::from("prop1"), prop1)].into_iter())
+                .unwrap();
+        let props = writer.into_props_temporal().unwrap();
+        assert_eq!(props.len(), 1);
+
+        assert_eq!(meta.temporal_prop_mapper().keys().len(), 1);
+        assert!(meta.temporal_prop_mapper().get_id("prop1").is_some());
+
+        let writer =
+            PropsMetaWriter::temporal(&meta, vec![(ArcStr::from("prop1"), prop2)].into_iter());
+
+        assert!(writer.is_err());
+        assert_eq!(meta.temporal_prop_mapper().keys().len(), 1);
+        assert!(meta.temporal_prop_mapper().get_id("prop1").is_some());
+    }
+}
diff --git a/db4-storage/src/resolver/mapping_resolver.rs b/db4-storage/src/resolver/mapping_resolver.rs
new file mode 100644
index 0000000000..d117f0404f
--- /dev/null
+++ b/db4-storage/src/resolver/mapping_resolver.rs
@@ -0,0 +1,305 @@
+use crate::resolver::{GIDResolverOps, Initialiser, MaybeInit, StorageError};
+use dashmap::{VacantEntry, mapref::entry::Entry};
+use lock_api::ArcMutexGuard;
+use once_cell::sync::OnceCell;
+use parking_lot::{Mutex, RawMutex};
+use raphtory_api::core::{
+    entities::{GID, GidRef, GidType, VID},
+    storage::FxDashMap,
+};
+use std::{
+    borrow::Borrow,
+    hash::Hash,
+    sync::{
+        Arc,
+        atomic::{AtomicUsize, Ordering},
+    },
+};
+use thiserror::Error;
+
+use std::path::Path;
+
+#[derive(Debug)]
+enum Map {
+    U64(FxDashMap<u64, MaybeVID>),
+    Str(FxDashMap<String, MaybeVID>),
+}
+
+#[derive(Debug, Copy, Clone)]
+enum MaybeVID {
+    VID(VID),
+    Init(usize),
+}
+
+impl MaybeVID {
+    fn value(self) -> Option<VID> {
+        match self {
+            MaybeVID::VID(vid) => Some(vid),
+            MaybeVID::Init(_) => None,
+        }
+    }
+}
+
+enum InitGuard {
+    Init {
+        init_id: usize,
+        guard: ArcMutexGuard<RawMutex, VID>,
+    },
+    Read(Arc<Mutex<VID>>),
+}
+
+#[derive(Error, Debug)]
+pub enum InvalidNodeId {
+    #[error("Node id {0} does not have the correct type, expected String")]
+    InvalidNodeIdU64(u64),
+    #[error("Node id {0} does not have the correct type, expected Numeric")]
+    InvalidNodeIdStr(String),
+}
+
+impl Map {
+    fn as_u64(&self) -> Option<&FxDashMap<u64, MaybeVID>> {
+        match self {
+            Map::U64(map) => Some(map),
+            _ => None,
+        }
+    }
+
+    fn as_str(&self) -> Option<&FxDashMap<String, MaybeVID>> {
+        match self {
+            Map::Str(map) => Some(map),
+            _ => None,
+        }
+    }
+}
+
+impl Default for Map {
+    fn default() -> Self {
+        Map::U64(FxDashMap::default())
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct MappingResolver {
+    map: OnceCell<Map>,
+    uninitialised: FxDashMap<usize, Arc<Mutex<VID>>>,
+    init_counter: AtomicUsize,
+}
+
+pub struct Init<'a> {
+    mapping: &'a MappingResolver,
+    init_id: usize,
+    gid: GID,
+    guard: ArcMutexGuard<RawMutex, VID>,
+}
+
+impl<'a> Initialiser for Init<'a> {
+    fn init(mut self, vid: VID) -> Result<(), StorageError> {
+        *self.guard = vid;
+        self.mapping
+            .set(self.gid.as_ref(), vid)
+            .expect("gid should have been validated");
+        self.mapping.uninitialised.remove(&self.init_id);
+        Ok(())
+    }
+}
+
+impl MappingResolver {
+    pub fn new_u64() -> Self {
+        MappingResolver {
+            map: OnceCell::with_value(Map::U64(Default::default())),
+            uninitialised: Default::default(),
+            init_counter: Default::default(),
+        }
+    }
+
+    pub fn new_str() -> Self {
+        MappingResolver {
+            map: OnceCell::with_value(Map::Str(Default::default())),
+            uninitialised: Default::default(),
+            init_counter: Default::default(),
+        }
+    }
+
+    fn push_uninit<K: Eq + Hash>(&self, entry: VacantEntry<K, MaybeVID>) -> InitGuard {
+        let lock = Arc::new(Mutex::new(VID::default()));
+        let guard = lock.lock_arc();
+        let init_id = self.init_counter.fetch_add(1, Ordering::Relaxed);
+        self.uninitialised.insert(init_id, lock);
+        entry.insert(MaybeVID::Init(init_id));
+        InitGuard::Init { init_id, guard }
+    }
+
+    fn get_uninit(&self, init_id: &usize) -> Arc<Mutex<VID>> {
+        self.uninitialised
+            .get(init_id)
+            .expect("initialisation guard should exist")
+            .clone()
+    }
+
+    fn get_value_from_map<Q, K>(&self, map: &FxDashMap<K, MaybeVID>, key: &Q) -> Option<VID>
+    where
+        K: Borrow<Q> + Eq + Hash,
+        Q: Hash + Eq + ?Sized,
+    {
+        map.get(key)?.value().value()
+    }
+
+    fn handle_init_guard(&self, init_guard: InitGuard, gid: GidRef) -> MaybeInit<Init<'_>> {
+        match init_guard {
+            InitGuard::Init { guard, init_id } => MaybeInit::Init(Init {
+                mapping: self,
+                init_id,
+                gid: gid.to_owned(),
+                guard,
+            }),
+            InitGuard::Read(guard) => MaybeInit::VID(*guard.lock()),
+        }
+    }
+}
+
+impl GIDResolverOps for MappingResolver {
+    type Init<'a> = Init<'a>;
+
+    fn new() -> Result<Self, StorageError>
+    where
+        Self: Sized,
+    {
+        Ok(MappingResolver {
+            map: OnceCell::new(),
+            uninitialised: Default::default(),
+            init_counter: Default::default(),
+        })
+    }
+
+    fn new_with_path(
+        _path: impl AsRef<Path>,
+        dtype: Option<GidType>,
+    ) -> Result<Self, StorageError> {
+        match dtype {
+            None => Self::new(),
+            Some(dtype) => {
+                let mapping = match dtype {
+                    GidType::U64 => MappingResolver::new_u64(),
+                    GidType::Str => MappingResolver::new_str(),
+                };
+                Ok(mapping)
+            }
+        }
+    }
+
+    fn len(&self) -> usize {
+        self.map.get().map_or(0, |map| match map {
+            Map::U64(map) => map.len(),
+            Map::Str(map) => map.len(),
+        })
+    }
+
+    fn dtype(&self) -> Option<GidType> {
+        self.map.get().map(|map| match map {
+            Map::U64(_) => GidType::U64,
+            Map::Str(_) => GidType::Str,
+        })
+    }
+
+    fn set(&self, gid: GidRef, vid: VID) -> Result<(), StorageError> {
+        let map = self.map.get_or_init(|| match gid {
+            GidRef::U64(_) => Map::U64(FxDashMap::default()),
+            GidRef::Str(_) => Map::Str(FxDashMap::default()),
+        });
+        match gid {
+            GidRef::U64(id) => {
+                map.as_u64()
+                    .ok_or(InvalidNodeId::InvalidNodeIdU64(id))?
+                    .insert(id, MaybeVID::VID(vid));
+            }
+            GidRef::Str(id) => {
+                let id = id.to_owned();
+                match map.as_str() {
+                    None => Err(InvalidNodeId::InvalidNodeIdStr(id))?,
+                    Some(map) => {
+                        map.insert(id, MaybeVID::VID(vid));
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn get_or_init(&self, gid: GidRef) -> Result<MaybeInit<Self::Init<'_>>, StorageError> {
+        let map = self.map.get_or_init(|| match &gid {
+            GidRef::U64(_) => Map::U64(FxDashMap::default()),
+            GidRef::Str(_) => Map::Str(FxDashMap::default()),
+        });
+        let vid_init = match gid {
+            GidRef::U64(key) => {
+                let map = map.as_u64().ok_or(InvalidNodeId::InvalidNodeIdU64(key))?;
+                let init_guard = match map.entry(key) {
+                    Entry::Occupied(id) => match id.get() {
+                        MaybeVID::VID(vid) => return Ok(MaybeInit::VID(*vid)),
+                        MaybeVID::Init(init_id) => InitGuard::Read(self.get_uninit(init_id)),
+                    },
+                    Entry::Vacant(entry) => self.push_uninit(entry),
+                };
+                self.handle_init_guard(init_guard, gid)
+            }
+            GidRef::Str(key) => {
+                let map = map
+                    .as_str()
+                    .ok_or_else(|| InvalidNodeId::InvalidNodeIdStr(key.into()))?;
+
+                let init_guard = match map.get(key) {
+                    None => match map.entry(key.to_owned()) {
+                        Entry::Occupied(entry) => match entry.get() {
+                            MaybeVID::VID(vid) => return Ok(MaybeInit::VID(*vid)),
+                            MaybeVID::Init(init_id) => InitGuard::Read(self.get_uninit(init_id)),
+                        },
+                        Entry::Vacant(entry) => self.push_uninit(entry),
+                    },
+                    Some(maybe_vid) => match maybe_vid.value() {
+                        MaybeVID::VID(vid) => return Ok(MaybeInit::VID(*vid)),
+                        MaybeVID::Init(init_id) => InitGuard::Read(self.get_uninit(init_id)),
+                    },
+                };
+                self.handle_init_guard(init_guard, gid)
+            }
+        };
+        Ok(vid_init)
+    }
+
+    fn validate_gids<'a>(
+        &self,
+        gids: impl IntoIterator<Item = GidRef<'a>>,
+    ) -> Result<(), StorageError> {
+        for gid in gids {
+            let map = self.map.get_or_init(|| match &gid {
+                GidRef::U64(_) => Map::U64(FxDashMap::default()),
+                GidRef::Str(_) => Map::Str(FxDashMap::default()),
+            });
+            match gid {
+                GidRef::U64(id) => {
+                    map.as_u64().ok_or(InvalidNodeId::InvalidNodeIdU64(id))?;
+                }
+                GidRef::Str(id) => {
+                    map.as_str()
+                        .ok_or_else(|| InvalidNodeId::InvalidNodeIdStr(id.into()))?;
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    fn get_str(&self, gid: &str) -> Option<VID> {
+        let map = self.map.get()?;
+        map.as_str().and_then(|m| self.get_value_from_map(m, gid))
+    }
+
+    fn get_u64(&self, gid: u64) -> Option<VID> {
+        let map = self.map.get()?;
+        map.as_u64().and_then(|m| self.get_value_from_map(m, &gid))
+    }
+
+    fn flush(&self) -> Result<(), StorageError> {
+        Ok(())
+    }
+}
diff --git a/db4-storage/src/resolver/mod.rs b/db4-storage/src/resolver/mod.rs
new file mode 100644
index 0000000000..32897531ee
--- /dev/null
+++ b/db4-storage/src/resolver/mod.rs
@@ -0,0 +1,78 @@
+use crate::error::StorageError;
+use raphtory_api::core::entities::{GidRef, GidType, VID};
+use std::path::Path;
+
+pub mod mapping_resolver;
+
+/// Either an initialiser or a `VID`. For equality checks, only VIDs are compared, initialisers are
+/// never considered equal.
+pub enum MaybeInit<I> {
+    VID(VID),
+    Init(I),
+}
+
+impl<I> MaybeInit<I> {
+    pub fn needs_init(&self) -> bool {
+        matches!(self, MaybeInit::Init(_))
+    }
+}
+
+impl<I> PartialEq for MaybeInit<I> {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (MaybeInit::VID(left), MaybeInit::VID(right)) => left == right,
+            _ => false,
+        }
+    }
+}
+
+pub trait Initialiser {
+    fn init(self, vid: VID) -> Result<(), StorageError>;
+}
+
+pub trait GIDResolverOps {
+    type Init<'a>: Initialiser
+    where
+        Self: 'a;
+
+    fn new() -> Result<Self, StorageError>
+    where
+        Self: Sized;
+
+    fn new_with_path(path: impl AsRef<Path>, dtype: Option<GidType>) -> Result<Self, StorageError>
+    where
+        Self: Sized;
+
+    fn len(&self) -> usize;
+
+    fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    fn dtype(&self) -> Option<GidType>;
+
+    fn set(&self, gid: GidRef, vid: VID) -> Result<(), StorageError>;
+
+    fn get_or_init<'a>(
+        &'a self,
+        gid: GidRef<'a>,
+    ) -> Result<MaybeInit<Self::Init<'a>>, StorageError>;
+
+    fn validate_gids<'a>(
+        &self,
+        gids: impl IntoIterator<Item = GidRef<'a>>,
+    ) -> Result<(), StorageError>;
+
+    fn get_str(&self, gid: &str) -> Option<VID>;
+
+    fn get_u64(&self, gid: u64) -> Option<VID>;
+
+    fn get(&self, gid: GidRef) -> Option<VID> {
+        match gid {
+            GidRef::Str(s) => self.get_str(s),
+            GidRef::U64(u) => self.get_u64(u),
+        }
+    }
+
+    fn flush(&self) -> Result<(), StorageError>;
+}
diff --git a/db4-storage/src/segments/additions.rs b/db4-storage/src/segments/additions.rs
new file mode 100644
index 0000000000..6b058e0429
--- /dev/null
+++ b/db4-storage/src/segments/additions.rs
@@ -0,0 +1,121 @@
+use std::ops::Range;
+
+use raphtory_api_macros::box_on_debug_lifetime;
+use raphtory_core::{
+    entities::{ELID, properties::tcell::TCell},
+    storage::timeindex::{EventTime, TimeIndexOps, TimeIndexWindow},
+};
+
+use crate::{gen_ts::EdgeEventOps, utils::Iter4};
+
+#[derive(Clone, Debug)]
+pub enum MemAdditions<'a> {
+    Edges(&'a TCell<ELID>),
+    Props(&'a TCell<Option<usize>>),
+    WEdges(TimeIndexWindow<'a, EventTime, TCell<ELID>>),
+    WProps(TimeIndexWindow<'a, EventTime, TCell<Option<usize>>>),
+}
+
+impl<'a> From<&'a TCell<ELID>> for MemAdditions<'a> {
+    fn from(edges: &'a TCell<ELID>) -> Self {
+        MemAdditions::Edges(edges)
+    }
+}
+
+impl<'a> From<&'a TCell<Option<usize>>> for MemAdditions<'a> {
+    fn from(props: &'a TCell<Option<usize>>) -> Self {
+        MemAdditions::Props(props)
+    }
+}
+
+impl<'a> EdgeEventOps<'a> for MemAdditions<'a> {
+    #[box_on_debug_lifetime]
+    fn edge_events(self) -> impl Iterator<Item = (EventTime, ELID)> + Send + Sync + 'a {
+        match self {
+            MemAdditions::Edges(edges) => Iter4::I(edges.iter().map(|(k, v)| (*k, *v))),
+            MemAdditions::WEdges(TimeIndexWindow::All(ti)) => {
+                Iter4::J(ti.iter().map(|(k, v)| (*k, *v)))
+            }
+            MemAdditions::WEdges(TimeIndexWindow::Range { timeindex, range }) => {
+                Iter4::K(timeindex.iter_window(range).map(|(k, v)| (*k, *v)))
+            }
+            _ => Iter4::L(std::iter::empty()),
+        }
+    }
+
+    #[box_on_debug_lifetime]
+    fn edge_events_rev(self) -> impl Iterator<Item = (EventTime, ELID)> + Send + Sync + 'a {
+        match self {
+            MemAdditions::Edges(edges) => Iter4::I(edges.iter().map(|(k, v)| (*k, *v)).rev()),
+            MemAdditions::WEdges(TimeIndexWindow::All(ti)) => {
+                Iter4::J(ti.iter().map(|(k, v)| (*k, *v)).rev())
+            }
+            MemAdditions::WEdges(TimeIndexWindow::Range { timeindex, range }) => {
+                Iter4::K(timeindex.iter_window(range).map(|(k, v)| (*k, *v)).rev())
+            }
+            _ => Iter4::L(std::iter::empty()),
+        }
+    }
+}
+
+impl<'a> TimeIndexOps<'a> for MemAdditions<'a> {
+    type IndexType = EventTime;
+
+    type RangeType = Self;
+
+    fn active(&self, w: Range<Self::IndexType>) -> bool {
+        match self {
+            MemAdditions::Props(props) => props.active(w),
+            MemAdditions::Edges(edges) => edges.active(w),
+            MemAdditions::WProps(window) => window.active(w),
+            MemAdditions::WEdges(window) => window.active(w),
+        }
+    }
+
+    fn range(&self, w: Range<Self::IndexType>) -> Self::RangeType {
+        match self {
+            MemAdditions::Props(props) => MemAdditions::WProps(props.range(w)),
+            MemAdditions::Edges(edges) => MemAdditions::WEdges(edges.range(w)),
+            MemAdditions::WProps(window) => MemAdditions::WProps(window.range(w)),
+            MemAdditions::WEdges(window) => MemAdditions::WEdges(window.range(w)),
+        }
+    }
+
+    #[box_on_debug_lifetime]
+    fn iter(self) -> impl Iterator<Item = Self::IndexType> + Send + Sync + 'a {
+        match self {
+            MemAdditions::Props(props) => Iter4::I(props.iter().map(|(k, _)| *k)),
+            MemAdditions::Edges(edges) => Iter4::J(edges.iter().map(|(k, _)| *k)),
+            MemAdditions::WProps(window) => Iter4::K(window.iter()),
+            MemAdditions::WEdges(window) => Iter4::L(window.iter()),
+        }
+    }
+
+    #[box_on_debug_lifetime]
+    fn iter_rev(self) -> impl Iterator<Item = Self::IndexType> + Send + Sync + 'a {
+        match self {
+            MemAdditions::Props(props) => Iter4::I(props.iter_rev()),
+            MemAdditions::Edges(edges) => Iter4::J(edges.iter_rev()),
+            MemAdditions::WProps(window) => Iter4::K(window.iter_rev()),
+            MemAdditions::WEdges(window) => Iter4::L(window.iter_rev()),
+        }
+    }
+
+    fn len(&self) -> usize {
+        match self {
+            MemAdditions::Props(props) => props.len(),
+            MemAdditions::Edges(edges) => edges.len(),
+            MemAdditions::WProps(window) => window.len(),
+            MemAdditions::WEdges(window) => window.len(),
+        }
+    }
+
+    fn is_empty(&self) -> bool {
+        match self {
+            MemAdditions::Edges(edges) => edges.is_empty(),
+            MemAdditions::Props(props) => props.is_empty(),
+            MemAdditions::WEdges(edges) => edges.is_empty(),
+            MemAdditions::WProps(edges) => edges.is_empty(),
+        }
+    }
+}
diff --git a/db4-storage/src/segments/edge/entry.rs b/db4-storage/src/segments/edge/entry.rs
new file mode 100644
index 0000000000..d2a506280d
--- /dev/null
+++ b/db4-storage/src/segments/edge/entry.rs
@@ -0,0 +1,194 @@
+use crate::{
+    EdgeAdditions, EdgeDeletions, EdgeTProps, LocalPOS,
+    api::edges::{EdgeEntryOps, EdgeRefOps},
+    gen_ts::{AdditionCellsRef, DeletionCellsRef, WithTimeCells},
+    generic_t_props::WithTProps,
+    segments::{additions::MemAdditions, edge::segment::MemEdgeSegment},
+};
+use raphtory_api::core::entities::{LayerId, properties::prop::Prop};
+use raphtory_core::{
+    entities::{
+        EID, Multiple, VID,
+        properties::{tcell::TCell, tprop::TPropCell},
+    },
+    storage::timeindex::{EventTime, TimeIndexOps},
+};
+
+#[derive(Debug)]
+pub struct MemEdgeEntry<'a, MES> {
+    pos: LocalPOS,
+    es: MES,
+    __marker: std::marker::PhantomData<&'a ()>,
+}
+
+impl<'a, MES: std::ops::Deref<Target = MemEdgeSegment>> MemEdgeEntry<'a, MES> {
+    pub fn new(pos: LocalPOS, es: MES) -> Self {
+        Self {
+            pos,
+            es,
+            __marker: std::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, MES: std::ops::Deref<Target = MemEdgeSegment> + Send + Sync> EdgeEntryOps<'a>
+    for MemEdgeEntry<'a, MES>
+{
+    type Ref<'b>
+        = MemEdgeRef<'b>
+    where
+        'a: 'b,
+        MES: 'b;
+
+    fn as_ref<'b>(&'b self) -> Self::Ref<'b>
+    where
+        'a: 'b,
+    {
+        MemEdgeRef {
+            pos: self.pos,
+            es: &self.es,
+        }
+    }
+}
+
+#[derive(Copy, Clone, Debug)]
+pub struct MemEdgeRef<'a> {
+    pos: LocalPOS,
+    es: &'a MemEdgeSegment,
+}
+
+impl<'a> MemEdgeRef<'a> {
+    pub fn new(pos: LocalPOS, es: &'a MemEdgeSegment) -> Self {
+        Self { pos, es }
+    }
+
+    pub fn has_layers(&self, layer_ids: &Multiple) -> bool {
+        layer_ids.iter().any(|layer_id| {
+            self.es
+                .as_ref()
+                .get(layer_id.0)
+                .is_some_and(|layer| layer.has_item(self.pos))
+        })
+    }
+}
+
+impl<'a> WithTimeCells<'a> for MemEdgeRef<'a> {
+    type TimeCell = MemAdditions<'a>;
+
+    fn t_props_tc(
+        self,
+        layer_id: LayerId,
+        range: Option<(EventTime, EventTime)>,
+    ) -> impl Iterator<Item = Self::TimeCell> + 'a {
+        self.es
+            .as_ref()
+            .get(layer_id.0)
+            .map(|layer| MemAdditions::Props(layer.times_from_props(self.pos)))
+            .into_iter()
+            .map(move |t_props| {
+                range
+                    .map(|(start, end)| t_props.range(start..end))
+                    .unwrap_or_else(|| t_props)
+            })
+    }
+
+    fn additions_tc(
+        self,
+        _layer_id: LayerId,
+        _range: Option<(EventTime, EventTime)>,
+    ) -> impl Iterator<Item = Self::TimeCell> + 'a {
+        std::iter::empty()
+    }
+
+    fn deletions_tc(
+        self,
+        layer_id: LayerId,
+        range: Option<(EventTime, EventTime)>,
+    ) -> impl Iterator<Item = Self::TimeCell> + 'a {
+        let deletions = self
+            .es
+            .as_ref()
+            .get(layer_id.0)
+            .map(|layer| layer.deletions(self.pos))
+            .unwrap_or(&TCell::Empty);
+        let t_cell = MemAdditions::Edges(deletions);
+        std::iter::once(
+            range
+                .map(|(start, end)| t_cell.range(start..end))
+                .unwrap_or_else(|| t_cell),
+        )
+    }
+
+    fn num_layers(&self) -> usize {
+        self.es.as_ref().len()
+    }
+}
+
+impl<'a> WithTProps<'a> for MemEdgeRef<'a> {
+    type TProp = TPropCell<'a>;
+
+    fn num_layers(&self) -> usize {
+        self.es.as_ref().len()
+    }
+
+    fn into_t_props(
+        self,
+        layer_id: LayerId,
+        prop_id: usize,
+    ) -> impl Iterator<Item = Self::TProp> + 'a {
+        let edge_pos = self.pos;
+        self.es
+            .as_ref()
+            .get(layer_id.0)
+            .into_iter()
+            .flat_map(move |layer| layer.t_prop(edge_pos, prop_id).into_iter())
+    }
+}
+
+impl<'a> EdgeRefOps<'a> for MemEdgeRef<'a> {
+    type Additions = EdgeAdditions<'a>;
+    type Deletions = EdgeDeletions<'a>;
+    type TProps = EdgeTProps<'a>;
+
+    fn edge(self, layer_id: LayerId) -> Option<(VID, VID)> {
+        self.es
+            .as_ref()
+            .get(layer_id.0)?
+            .get(self.pos)
+            .map(|entry| (entry.src, entry.dst))
+    }
+
+    fn layer_additions(self, layer_id: LayerId) -> Self::Additions {
+        EdgeAdditions::new_with_layer(AdditionCellsRef::new(self), layer_id.0)
+    }
+
+    fn layer_deletions(self, layer_id: LayerId) -> Self::Deletions {
+        EdgeDeletions::new_with_layer(DeletionCellsRef::new(self), layer_id.0)
+    }
+
+    fn c_prop(self, layer_id: LayerId, prop_id: usize) -> Option<Prop> {
+        self.es.as_ref().get(layer_id.0)?.c_prop(self.pos, prop_id)
+    }
+
+    fn layer_t_prop(self, layer_id: LayerId, prop_id: usize) -> Self::TProps {
+        EdgeTProps::new_with_layer(self, layer_id, prop_id)
+    }
+
+    fn src(&self) -> Option<VID> {
+        self.es.as_ref()[0].get(self.pos).map(|entry| entry.src)
+    }
+
+    fn dst(&self) -> Option<VID> {
+        self.es.as_ref()[0].get(self.pos).map(|entry| entry.dst)
+    }
+
+    fn edge_id(&self) -> EID {
+        let segment_id = self.es.as_ref()[0].segment_id();
+        let max_page_len = self.es.as_ref()[0].max_page_len();
+        self.pos.as_eid(segment_id, max_page_len)
+    }
+
+    fn internal_num_layers(self) -> usize {
+        self.es.as_ref().len()
+    }
+}
diff --git a/db4-storage/src/segments/edge/mod.rs b/db4-storage/src/segments/edge/mod.rs
new file mode 100644
index 0000000000..d0b743bd85
--- /dev/null
+++ b/db4-storage/src/segments/edge/mod.rs
@@ -0,0 +1,2 @@
+pub mod entry;
+pub mod segment;
diff --git a/db4-storage/src/segments/edge/segment.rs b/db4-storage/src/segments/edge/segment.rs
new file mode 100644
index 0000000000..2c4384146d
--- /dev/null
+++ b/db4-storage/src/segments/edge/segment.rs
@@ -0,0 +1,786 @@
+use crate::{
+    LocalPOS,
+    api::edges::{EdgeSegmentOps, LockedESegment},
+    error::StorageError,
+    persist::{config::ConfigOps, strategy::PersistenceStrategy},
+    properties::PropMutEntry,
+    segments::{
+        HasRow, SegmentContainer,
+        edge::entry::{MemEdgeEntry, MemEdgeRef},
+    },
+    utils::Iter4,
+    wal::LSN,
+};
+use parking_lot::lock_api::ArcRwLockReadGuard;
+use raphtory_api::core::{
+    entities::{
+        LayerId, VID,
+        properties::{
+            meta::{Meta, STATIC_GRAPH_LAYER_ID},
+            prop::AsPropRef,
+        },
+    },
+    storage::dict_mapper::MaybeNew,
+};
+use raphtory_api_macros::box_on_debug_lifetime;
+use raphtory_core::{
+    entities::LayerIds,
+    storage::timeindex::{AsTime, EventTime},
+};
+use rayon::prelude::*;
+use std::{
+    ops::{Deref, DerefMut},
+    path::PathBuf,
+    sync::{
+        Arc,
+        atomic::{self, AtomicU32, AtomicUsize, Ordering},
+    },
+};
+
+#[derive(Debug, Default)]
+pub struct EdgeEntry {
+    pub src: VID,
+    pub dst: VID,
+    pub row: usize,
+}
+
+impl HasRow for EdgeEntry {
+    fn row(&self) -> usize {
+        self.row
+    }
+
+    fn row_mut(&mut self) -> &mut usize {
+        &mut self.row
+    }
+}
+
+#[derive(Debug)]
+pub struct MemEdgeSegment {
+    layers: Vec<SegmentContainer<EdgeEntry>>,
+    est_size: usize,
+    global_memory_tracker: Arc<AtomicUsize>,
+    lsn: LSN,
+}
+
+impl AsRef<[SegmentContainer<EdgeEntry>]> for MemEdgeSegment {
+    fn as_ref(&self) -> &[SegmentContainer<EdgeEntry>] {
+        &self.layers
+    }
+}
+
+impl AsMut<[SegmentContainer<EdgeEntry>]> for MemEdgeSegment {
+    fn as_mut(&mut self) -> &mut [SegmentContainer<EdgeEntry>] {
+        &mut self.layers
+    }
+}
+
+impl MemEdgeSegment {
+    pub fn new(
+        segment_id: usize,
+        max_page_len: u32,
+        meta: Arc<Meta>,
+        global_memory_tracker: Arc<AtomicUsize>,
+    ) -> Self {
+        Self {
+            layers: vec![SegmentContainer::new(segment_id, max_page_len, meta)],
+            est_size: 0,
+            global_memory_tracker,
+            lsn: 0,
+        }
+    }
+
+    pub fn increment_global_memory(&self, increment: usize) {
+        self.global_memory_tracker
+            .fetch_add(increment, Ordering::Relaxed);
+    }
+
+    pub fn edge_meta(&self) -> &Arc<Meta> {
+        self.layers[0].meta()
+    }
+
+    pub fn swap_out_layers(&mut self) -> Vec<SegmentContainer<EdgeEntry>> {
+        let layers = self
+            .as_mut()
+            .iter_mut()
+            .map(|head_guard| {
+                let mut old_head = SegmentContainer::new(
+                    head_guard.segment_id(),
+                    head_guard.max_page_len(),
+                    head_guard.meta().clone(),
+                );
+                std::mem::swap(&mut *head_guard, &mut old_head);
+                old_head
+            })
+            .collect::<Vec<_>>();
+        self.est_size = 0; // Reset estimated size after swapping out layers
+        layers
+    }
+
+    pub fn get_or_create_layer(&mut self, layer_id: LayerId) -> &mut SegmentContainer<EdgeEntry> {
+        let layer_id = layer_id.0;
+        if layer_id >= self.layers.len() {
+            let max_page_len = self.layers[0].max_page_len();
+            let segment_id = self.layers[0].segment_id();
+            let meta = self.layers[0].meta().clone();
+            self.layers.resize_with(layer_id + 1, || {
+                SegmentContainer::new(segment_id, max_page_len, meta.clone())
+            });
+        }
+        &mut self.layers[layer_id]
+    }
+
+    pub fn get_layer(&self, layer_id: LayerId) -> Option<&SegmentContainer<EdgeEntry>> {
+        self.layers.get(layer_id.0)
+    }
+
+    pub fn est_size(&self) -> usize {
+        self.est_size
+    }
+
+    pub fn lsn(&self) -> u64 {
+        self.lsn
+    }
+
+    pub fn set_lsn(&mut self, lsn: u64) {
+        self.lsn = lsn;
+    }
+
+    /// Replaces this segment with an empty instance, returning the old segment
+    /// with its data.
+    ///
+    /// The new segment will have the same number of layers as the original.
+    pub fn take(&mut self) -> Self {
+        let layers = self.layers.iter_mut().map(|layer| layer.take()).collect();
+        let est_size = self.est_size();
+        self.est_size = 0;
+
+        Self {
+            layers,
+            est_size,
+            global_memory_tracker: self.global_memory_tracker.clone(),
+            lsn: self.lsn,
+        }
+    }
+
+    pub fn max_page_len(&self) -> u32 {
+        self.layers[0].max_page_len()
+    }
+
+    pub fn get_edge(&self, edge_pos: LocalPOS, layer_id: LayerId) -> Option<(VID, VID)> {
+        self.layers
+            .get(layer_id.0)?
+            .get(edge_pos)
+            .map(|entry| (entry.src, entry.dst))
+    }
+
+    /// insert an edge
+    ///
+    /// returns a boolean flag indicating if the edge is new
+    pub fn insert_edge_internal<T: AsTime, P: AsPropRef>(
+        &mut self,
+        t: T,
+        edge_pos: LocalPOS,
+        src: VID,
+        dst: VID,
+        layer_id: LayerId,
+        props: impl IntoIterator<Item = (usize, P)>,
+    ) -> bool {
+        // Ensure we have enough layers
+        self.ensure_layer(layer_id);
+        let est_size = self.layers[layer_id.0].est_size();
+
+        let (local_row, is_new) = self
+            .reserve_local_row(edge_pos, src, dst, layer_id)
+            .into_inner_with_status();
+
+        let mut prop_entry: PropMutEntry<'_> = self.layers[layer_id.0]
+            .properties_mut()
+            .get_mut_entry(local_row);
+
+        let ts = EventTime::new(t.t(), t.i());
+        prop_entry.append_t_props(ts, props);
+
+        let layer_est_size = self.layers[layer_id.0].est_size();
+        self.est_size += layer_est_size.saturating_sub(est_size);
+        is_new
+    }
+
+    /// delete an edge
+    ///
+    /// returns a boolean flag indicating if the edge is new
+    pub fn delete_edge_internal<T: AsTime>(
+        &mut self,
+        t: T,
+        edge_pos: LocalPOS,
+        src: VID,
+        dst: VID,
+        layer_id: LayerId,
+    ) -> bool {
+        let t = EventTime::new(t.t(), t.i());
+
+        // Ensure we have enough layers
+        self.ensure_layer(layer_id);
+        let est_size = self.layers[layer_id.0].est_size();
+
+        let (local_row, is_new) = self
+            .reserve_local_row(edge_pos, src, dst, layer_id)
+            .into_inner_with_status();
+        let props = self.layers[layer_id.0].properties_mut();
+        props.get_mut_entry(local_row).deletion_timestamp(t, None);
+        let layer_est_size = self.layers[layer_id.0].est_size();
+        self.est_size += layer_est_size.saturating_sub(est_size);
+        is_new
+    }
+
+    /// add static edge
+    ///
+    /// returns flag indicating if edge is new
+    pub fn insert_static_edge_internal(
+        &mut self,
+        edge_pos: LocalPOS,
+        src: impl Into<VID>,
+        dst: impl Into<VID>,
+        layer_id: LayerId,
+    ) -> bool {
+        let src = src.into();
+        let dst = dst.into();
+
+        // Ensure we have enough layers
+        self.ensure_layer(layer_id);
+        let est_size = self.layers[layer_id.0].est_size();
+
+        let is_new = self
+            .reserve_local_row(edge_pos, src, dst, layer_id)
+            .is_new();
+        let layer_est_size = self.layers[layer_id.0].est_size();
+        self.est_size += layer_est_size.saturating_sub(est_size);
+        is_new
+    }
+
+    fn ensure_layer(&mut self, layer_id: LayerId) {
+        let layer_id = layer_id.0;
+        if layer_id >= self.layers.len() {
+            // Get details from first layer to create consistent new layers.
+            if let Some(first_layer) = self.layers.first() {
+                let segment_id = first_layer.segment_id();
+                let max_page_len = first_layer.max_page_len();
+                let meta = first_layer.meta().clone();
+
+                // Extend with new layers
+                while self.layers.len() <= layer_id {
+                    self.layers.push(SegmentContainer::new(
+                        segment_id,
+                        max_page_len,
+                        meta.clone(),
+                    ));
+                }
+            }
+        }
+    }
+
+    fn reserve_local_row(
+        &mut self,
+        edge_pos: LocalPOS,
+        src: impl Into<VID>,
+        dst: impl Into<VID>,
+        layer_id: LayerId,
+    ) -> MaybeNew<usize> {
+        let src = src.into();
+        let dst = dst.into();
+
+        let mut row = self.layers[layer_id.0].reserve_local_row(edge_pos);
+        let inner = row.as_mut().inner();
+        inner.src = src;
+        inner.dst = dst;
+        row.map(|row| row.row)
+    }
+
+    pub fn check_metadata<P: AsPropRef>(
+        &self,
+        edge_pos: LocalPOS,
+        layer_id: LayerId,
+        props: &[(usize, P)],
+    ) -> Result<(), StorageError> {
+        if let Some(layer) = self.layers.get(layer_id.0) {
+            layer.check_metadata(edge_pos, props)?;
+        }
+
+        Ok(())
+    }
+
+    pub fn update_const_properties<P: AsPropRef>(
+        &mut self,
+        edge_pos: LocalPOS,
+        src: VID,
+        dst: VID,
+        layer_id: LayerId,
+        props: impl IntoIterator<Item = (usize, P)>,
+    ) {
+        // Ensure we have enough layers
+        self.ensure_layer(layer_id);
+        let est_size = self.layers[layer_id.0].est_size();
+        let local_row = self.reserve_local_row(edge_pos, src, dst, layer_id).inner();
+        let mut prop_entry: PropMutEntry<'_> = self.layers[layer_id.0]
+            .properties_mut()
+            .get_mut_entry(local_row);
+        prop_entry.append_const_props(props);
+
+        let layer_est_size = self.layers[layer_id.0].est_size() + 8;
+        self.est_size += layer_est_size.saturating_sub(est_size);
+    }
+
+    pub fn has_edge(&self, edge_pos: LocalPOS, layer_id: LayerId) -> bool {
+        self.layers
+            .get(layer_id.0)
+            .is_some_and(|layer| layer.has_item(edge_pos))
+    }
+
+    pub fn latest(&self) -> Option<EventTime> {
+        Iterator::max(self.layers.iter().filter_map(|seg| seg.latest()))
+    }
+
+    pub fn earliest(&self) -> Option<EventTime> {
+        Iterator::min(self.layers.iter().filter_map(|seg| seg.earliest()))
+    }
+
+    pub fn t_len(&self) -> usize {
+        self.layers.iter().map(|seg| seg.t_len()).sum()
+    }
+}
+
+impl Drop for MemEdgeSegment {
+    fn drop(&mut self) {
+        self.global_memory_tracker
+            .fetch_sub(self.est_size, Ordering::Relaxed);
+    }
+}
+
+// Update EdgeSegmentView implementation to use multiple layers
+#[derive(Debug)]
+pub struct EdgeSegmentView<EXT> {
+    segment: Arc<parking_lot::RwLock<MemEdgeSegment>>,
+    segment_id: usize,
+    num_edges: AtomicU32,
+    ext: EXT,
+}
+
+#[derive(Debug)]
+pub struct ArcLockedSegmentView {
+    inner: ArcRwLockReadGuard<parking_lot::RawRwLock, MemEdgeSegment>,
+    num_edges: u32,
+}
+
+impl ArcLockedSegmentView {
+    fn edge_iter_layer<'a>(
+        &'a self,
+        layer_id: LayerId,
+    ) -> impl Iterator<Item = MemEdgeRef<'a>> + Send + Sync + 'a {
+        self.inner
+            .layers
+            .get(layer_id.0)
+            .into_iter()
+            .flat_map(|layer| layer.filled_positions())
+            .map(move |pos| MemEdgeRef::new(pos, &self.inner))
+    }
+
+    fn edge_par_iter_layer<'a>(
+        &'a self,
+        layer_id: LayerId,
+    ) -> impl ParallelIterator<Item = MemEdgeRef<'a>> + 'a {
+        self.inner
+            .layers
+            .get(layer_id.0)
+            .into_par_iter()
+            .flat_map(|layer| layer.filled_positions_par())
+            .map(move |pos| MemEdgeRef::new(pos, &self.inner))
+    }
+}
+
+impl LockedESegment for ArcLockedSegmentView {
+    type EntryRef<'a> = MemEdgeRef<'a>;
+
+    fn entry_ref<'a>(&'a self, edge_pos: impl Into<LocalPOS>) -> Self::EntryRef<'a>
+    where
+        Self: 'a,
+    {
+        let edge_pos = edge_pos.into();
+        MemEdgeRef::new(edge_pos, &self.inner)
+    }
+
+    #[box_on_debug_lifetime]
+    fn edge_iter<'a, 'b: 'a>(
+        &'a self,
+        layer_ids: &'b LayerIds,
+    ) -> impl Iterator<Item = Self::EntryRef<'a>> + Send + Sync + 'a {
+        match layer_ids {
+            LayerIds::None => Iter4::I(std::iter::empty()),
+            LayerIds::All => Iter4::J(self.edge_iter_layer(STATIC_GRAPH_LAYER_ID)),
+            LayerIds::One(layer_id) => Iter4::K(self.edge_iter_layer(*layer_id)),
+            LayerIds::Multiple(multiple) => Iter4::L(
+                self.edge_iter_layer(STATIC_GRAPH_LAYER_ID)
+                    .filter(|pos| pos.has_layers(multiple)),
+            ),
+        }
+    }
+
+    fn edge_par_iter<'a, 'b: 'a>(
+        &'a self,
+        layer_ids: &'b LayerIds,
+    ) -> impl ParallelIterator<Item = Self::EntryRef<'a>> + 'a {
+        match layer_ids {
+            LayerIds::None => Iter4::I(rayon::iter::empty()),
+            LayerIds::All => Iter4::J(self.edge_par_iter_layer(STATIC_GRAPH_LAYER_ID)),
+            LayerIds::One(layer_id) => Iter4::K(self.edge_par_iter_layer(*layer_id)),
+            LayerIds::Multiple(multiple) => Iter4::L(
+                self.edge_par_iter_layer(STATIC_GRAPH_LAYER_ID)
+                    .filter(|pos| pos.has_layers(multiple)),
+            ),
+        }
+    }
+
+    fn num_edges(&self) -> u32 {
+        self.num_edges
+    }
+}
+
+impl<P: PersistenceStrategy<ES = EdgeSegmentView<P>>> EdgeSegmentOps for EdgeSegmentView<P> {
+    type Extension = P;
+
+    type Entry<'a> = MemEdgeEntry<'a, parking_lot::RwLockReadGuard<'a, MemEdgeSegment>>;
+
+    type ArcLockedSegment = ArcLockedSegmentView;
+
+    fn extension(&self) -> &Self::Extension {
+        &self.ext
+    }
+
+    fn latest(&self) -> Option<EventTime> {
+        self.head().latest()
+    }
+
+    fn earliest(&self) -> Option<EventTime> {
+        self.head().earliest()
+    }
+
+    fn t_len(&self) -> usize {
+        self.head().t_len()
+    }
+
+    fn num_layers(&self) -> usize {
+        self.head().layers.len()
+    }
+
+    fn layer_count(&self, layer_id: LayerId) -> u32 {
+        self.head()
+            .get_layer(layer_id)
+            .map_or(0, |layer| layer.len())
+    }
+
+    fn load(
+        _page_id: usize,
+        _max_page_len: u32,
+        _meta: Arc<Meta>,
+        _path: impl AsRef<std::path::Path>,
+        _ext: Self::Extension,
+    ) -> Result<Self, StorageError>
+    where
+        Self: Sized,
+    {
+        Err(StorageError::GenericFailure(
+            "load not supported".to_string(),
+        ))
+    }
+
+    fn new(page_id: usize, meta: Arc<Meta>, _path: Option<PathBuf>, ext: Self::Extension) -> Self {
+        let max_page_len = ext.config().max_edge_page_len();
+
+        Self {
+            segment: parking_lot::RwLock::new(MemEdgeSegment::new(
+                page_id,
+                max_page_len,
+                meta,
+                ext.memory_tracker().clone(),
+            ))
+            .into(),
+            segment_id: page_id,
+            num_edges: AtomicU32::new(0),
+            ext,
+        }
+    }
+
+    fn segment_id(&self) -> usize {
+        self.segment_id
+    }
+
+    fn edges_counter(&self) -> &AtomicU32 {
+        &self.num_edges
+    }
+
+    fn head(&self) -> parking_lot::RwLockReadGuard<'_, MemEdgeSegment> {
+        self.segment.read_recursive()
+    }
+
+    fn head_arc(&self) -> ArcRwLockReadGuard<parking_lot::RawRwLock, MemEdgeSegment> {
+        self.segment.read_arc_recursive()
+    }
+
+    fn head_mut(&self) -> parking_lot::RwLockWriteGuard<'_, MemEdgeSegment> {
+        self.segment.write()
+    }
+
+    fn try_head_mut(&self) -> Option<parking_lot::RwLockWriteGuard<'_, MemEdgeSegment>> {
+        self.segment.try_write()
+    }
+
+    fn set_dirty(&self, _dirty: bool) {}
+
+    fn is_dirty(&self) -> bool {
+        true
+    }
+
+    fn notify_write(
+        &self,
+        _head_lock: impl DerefMut<Target = MemEdgeSegment>,
+    ) -> Result<(), StorageError> {
+        Ok(())
+    }
+
+    fn increment_num_edges(&self) -> u32 {
+        self.num_edges.fetch_add(1, atomic::Ordering::Relaxed)
+    }
+
+    fn has_edge(
+        &self,
+        edge_pos: LocalPOS,
+        layer_id: LayerId,
+        locked_head: impl Deref<Target = MemEdgeSegment>,
+    ) -> bool {
+        locked_head.has_edge(edge_pos, layer_id)
+    }
+
+    fn immut_has_edge(&self, _edge_pos: LocalPOS, _layer_id: LayerId) -> bool {
+        false
+    }
+
+    fn get_edge(
+        &self,
+        edge_pos: LocalPOS,
+        layer_id: LayerId,
+        locked_head: impl Deref<Target = MemEdgeSegment>,
+    ) -> Option<(VID, VID)> {
+        locked_head.get_edge(edge_pos, layer_id)
+    }
+
+    fn entry<'a>(&'a self, edge_pos: LocalPOS) -> Self::Entry<'a> {
+        MemEdgeEntry::new(edge_pos, self.head())
+    }
+
+    fn layer_entry<'a>(
+        &'a self,
+        edge_pos: LocalPOS,
+        layer_id: LayerId,
+        locked_head: Option<parking_lot::RwLockReadGuard<'a, MemEdgeSegment>>,
+    ) -> Option<Self::Entry<'a>> {
+        locked_head.and_then(|locked_head| {
+            let layer = locked_head.as_ref().get(layer_id.0)?;
+            layer
+                .has_item(edge_pos)
+                .then(|| MemEdgeEntry::new(edge_pos, locked_head))
+        })
+    }
+
+    fn locked(self: &Arc<Self>) -> Self::ArcLockedSegment {
+        ArcLockedSegmentView {
+            inner: self.head_arc(),
+            num_edges: self.num_edges(),
+        }
+    }
+
+    fn vacuum(
+        &self,
+        _locked_head: impl DerefMut<Target = MemEdgeSegment>,
+    ) -> Result<(), StorageError> {
+        Ok(())
+    }
+
+    fn immut_lsn(&self) -> LSN {
+        0
+    }
+
+    fn flush(&self) -> Result<(), StorageError> {
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::{
+        Config,
+        pages::{edge_page::writer::EdgeWriter, layer_counter::GraphStats},
+        persist::strategy::NoOpStrategy,
+    };
+    use raphtory_api::core::entities::properties::{
+        meta::{Meta, STATIC_GRAPH_LAYER_ID},
+        prop::{Prop, PropType},
+    };
+    use raphtory_core::storage::timeindex::EventTime;
+
+    fn create_test_segment() -> MemEdgeSegment {
+        let meta = Arc::new(Meta::default());
+        MemEdgeSegment::new(1, 100, meta, Arc::new(AtomicUsize::new(0)))
+    }
+
+    #[test]
+    fn test_insert_edge_internal_baseline() {
+        let mut segment = create_test_segment();
+
+        // Insert a few edges using insert_edge_internal
+        segment.insert_edge_internal(
+            EventTime::new(1, 0),
+            LocalPOS(0),
+            VID(1),
+            VID(2),
+            LayerId(0),
+            vec![(0, Prop::from("test1"))],
+        );
+
+        segment.insert_edge_internal(
+            EventTime::new(2, 1),
+            LocalPOS(1),
+            VID(3),
+            VID(4),
+            LayerId(0),
+            vec![(0, Prop::from("test2"))],
+        );
+
+        segment.insert_edge_internal(
+            EventTime::new(3, 2),
+            LocalPOS(2),
+            VID(5),
+            VID(6),
+            LayerId(0),
+            vec![(0, Prop::from("test3"))],
+        );
+
+        // Verify edges exist
+        assert!(segment.has_edge(LocalPOS(0), LayerId(0)));
+        assert!(segment.has_edge(LocalPOS(1), LayerId(0)));
+        assert!(segment.has_edge(LocalPOS(2), LayerId(0)));
+
+        // Verify edge data
+        assert_eq!(
+            segment.get_edge(LocalPOS(0), LayerId(0)),
+            Some((VID(1), VID(2)))
+        );
+        assert_eq!(
+            segment.get_edge(LocalPOS(1), LayerId(0)),
+            Some((VID(3), VID(4)))
+        );
+        assert_eq!(
+            segment.get_edge(LocalPOS(2), LayerId(0)),
+            Some((VID(5), VID(6)))
+        );
+
+        // Verify time length increased
+        assert_eq!(segment.t_len(), 3);
+    }
+
+    #[test]
+    fn est_size_changes() {
+        let meta = Arc::new(Meta::default());
+        let ext = NoOpStrategy::new(Config::default(), None).unwrap();
+        let stats = GraphStats::new();
+        let segment = EdgeSegmentView::new(1, meta.clone(), None, ext.clone());
+        let head = segment.head_mut();
+        let mut writer = EdgeWriter::new(&stats, &segment, head);
+        assert_eq!(writer.writer.est_size(), 0);
+        writer.add_edge(
+            EventTime::new(1, 0),
+            LocalPOS(0),
+            VID(1),
+            VID(2),
+            vec![(0, Prop::from("test"))],
+            STATIC_GRAPH_LAYER_ID,
+        );
+
+        let est_size1 = writer.writer.est_size();
+
+        assert!(est_size1 > 0);
+        writer.delete_edge(
+            EventTime::new(2, 3),
+            LocalPOS(0),
+            VID(5),
+            VID(3),
+            STATIC_GRAPH_LAYER_ID,
+        );
+
+        let est_size2 = writer.writer.est_size();
+
+        assert!(
+            est_size2 > est_size1,
+            "Expected size to increase after deletion, but it did not."
+        );
+
+        // same edge insertion again to check size increase
+        writer.add_edge(
+            EventTime::new(3, 0),
+            LocalPOS(1),
+            VID(4),
+            VID(6),
+            vec![(0, Prop::from("test2"))],
+            STATIC_GRAPH_LAYER_ID,
+        );
+
+        let est_size3 = writer.writer.est_size();
+        assert!(
+            est_size3 > est_size2,
+            "Expected size to increase after re-insertion, but it did not."
+        );
+
+        // Insert a static edge
+        writer.add_static_edge(Some(LocalPOS(1)), 4, 6, false);
+
+        let est_size4 = writer.writer.est_size();
+        assert_eq!(
+            est_size4, est_size3,
+            "Expected size to remain the same after static edge insertion, but it changed."
+        );
+
+        let prop_id = meta
+            .metadata_mapper()
+            .get_or_create_and_validate("a", PropType::U8)
+            .unwrap()
+            .inner();
+
+        writer.update_c_props(
+            LocalPOS(1),
+            VID(4),
+            VID(6),
+            STATIC_GRAPH_LAYER_ID,
+            [(prop_id, Prop::U8(2))],
+        );
+
+        let est_size5 = writer.writer.est_size();
+        assert!(
+            est_size5 > est_size4,
+            "Expected size to increase after updating properties, but it did not."
+        );
+
+        // update const properties for the other edge, hard to predict size change
+        // segment.update_const_properties(LocalPOS(0), 1, 2, 0, [(prop_id, Prop::U8(3))]);
+
+        // let est_size6 = segment.est_size();
+        // assert!(
+        //     est_size6 > est_size5,
+        //     "Expected size to increase after updating properties for the other edge, but it did not."
+        // );
+
+        drop(writer);
+        // global size should be the last size of the writer after drop
+        assert_eq!(ext.estimated_size(), est_size5);
+        drop(segment);
+        // global size should be 0 after the segment is dropped
+        assert_eq!(ext.estimated_size(), 0);
+    }
+}
diff --git a/db4-storage/src/segments/graph_prop/entry.rs b/db4-storage/src/segments/graph_prop/entry.rs
new file mode 100644
index 0000000000..2fa04494a6
--- /dev/null
+++ b/db4-storage/src/segments/graph_prop/entry.rs
@@ -0,0 +1,79 @@
+use crate::{
+    GraphTProps,
+    api::graph_props::{GraphPropEntryOps, GraphPropRefOps},
+    generic_t_props::WithTProps,
+    segments::graph_prop::segment::MemGraphPropSegment,
+};
+use parking_lot::RwLockReadGuard;
+use raphtory_api::core::entities::{LayerId, properties::prop::Prop};
+use raphtory_core::entities::properties::tprop::TPropCell;
+use std::ops::Deref;
+
+/// A borrowed view enabling read operations on an in-memory graph segment.
+pub struct MemGraphPropEntry<'a> {
+    mem: RwLockReadGuard<'a, MemGraphPropSegment>,
+}
+
+impl<'a> MemGraphPropEntry<'a> {
+    pub fn new(mem: RwLockReadGuard<'a, MemGraphPropSegment>) -> Self {
+        Self { mem }
+    }
+}
+
+impl<'a> GraphPropEntryOps<'a> for MemGraphPropEntry<'a> {
+    type Ref<'b>
+        = MemGraphPropRef<'b>
+    where
+        'a: 'b;
+
+    fn as_ref<'b>(&'b self) -> Self::Ref<'b>
+    where
+        'a: 'b,
+    {
+        MemGraphPropRef {
+            mem: self.mem.deref(),
+        }
+    }
+}
+
+/// A lightweight, copyable reference to graph properties.
+#[derive(Copy, Clone, Debug)]
+pub struct MemGraphPropRef<'a> {
+    mem: &'a MemGraphPropSegment,
+}
+
+impl<'a> MemGraphPropRef<'a> {
+    pub fn new(mem: &'a MemGraphPropSegment) -> Self {
+        Self { mem }
+    }
+}
+
+impl<'a> WithTProps<'a> for MemGraphPropRef<'a> {
+    type TProp = TPropCell<'a>;
+
+    fn num_layers(&self) -> usize {
+        // TODO: Support multiple layers for graph props.
+        1
+    }
+
+    fn into_t_props(
+        self,
+        _layer_id: LayerId,
+        prop_id: usize,
+    ) -> impl Iterator<Item = Self::TProp> + Send + Sync + 'a {
+        // TODO: Support multiple layers for graph props.
+        self.mem.get_temporal_prop(prop_id).into_iter()
+    }
+}
+
+impl<'a> GraphPropRefOps<'a> for MemGraphPropRef<'a> {
+    type TProps = GraphTProps<'a>;
+
+    fn get_temporal_prop(self, prop_id: usize) -> Self::TProps {
+        GraphTProps::new_with_layer(self, MemGraphPropSegment::DEFAULT_LAYER, prop_id)
+    }
+
+    fn get_metadata(self, prop_id: usize) -> Option<Prop> {
+        self.mem.get_metadata(prop_id)
+    }
+}
diff --git a/db4-storage/src/segments/graph_prop/mod.rs b/db4-storage/src/segments/graph_prop/mod.rs
new file mode 100644
index 0000000000..ec97be2422
--- /dev/null
+++ b/db4-storage/src/segments/graph_prop/mod.rs
@@ -0,0 +1,101 @@
+pub mod entry;
+pub mod segment;
+
+use crate::{
+    api::graph_props::GraphPropSegmentOps,
+    error::StorageError,
+    persist::strategy::PersistenceStrategy,
+    segments::graph_prop::{entry::MemGraphPropEntry, segment::MemGraphPropSegment},
+    wal::LSN,
+};
+use parking_lot::{RwLock, RwLockReadGuard, RwLockWriteGuard};
+use raphtory_api::core::entities::properties::meta::Meta;
+use std::{
+    path::Path,
+    sync::{
+        Arc,
+        atomic::{AtomicBool, AtomicUsize, Ordering},
+    },
+};
+
+/// `GraphPropSegmentView` manages graph temporal properties and graph metadata
+/// (constant properties). Reads / writes are always served from the in-memory segment.
+#[derive(Debug)]
+pub struct GraphPropSegmentView<P: PersistenceStrategy> {
+    /// In-memory segment that contains the latest graph properties
+    /// and graph metadata writes.
+    head: Arc<RwLock<MemGraphPropSegment>>,
+
+    /// Estimated size of the segment in bytes.
+    est_size: AtomicUsize,
+
+    is_dirty: AtomicBool,
+
+    _persistent: P,
+}
+
+impl<P: PersistenceStrategy> GraphPropSegmentOps for GraphPropSegmentView<P> {
+    type Extension = P;
+
+    type Entry<'a> = MemGraphPropEntry<'a>;
+
+    fn new(meta: Arc<Meta>, _path: Option<&Path>, ext: Self::Extension) -> Self {
+        Self {
+            head: Arc::new(RwLock::new(MemGraphPropSegment::new_with_meta(meta))),
+            est_size: AtomicUsize::new(0),
+            is_dirty: AtomicBool::new(false),
+            _persistent: ext,
+        }
+    }
+
+    fn load(
+        _meta: Arc<Meta>,
+        _path: impl AsRef<Path>,
+        _ext: Self::Extension,
+    ) -> Result<Self, StorageError> {
+        Err(StorageError::GenericFailure(
+            "load not supported".to_string(),
+        ))
+    }
+
+    fn head(&self) -> RwLockReadGuard<'_, MemGraphPropSegment> {
+        self.head.read()
+    }
+
+    fn head_mut(&self) -> RwLockWriteGuard<'_, MemGraphPropSegment> {
+        self.head.write()
+    }
+
+    fn entry(&self) -> Self::Entry<'_> {
+        let head = self.head.read();
+
+        MemGraphPropEntry::new(head)
+    }
+
+    fn increment_est_size(&self, size: usize) {
+        self.est_size.fetch_add(size, Ordering::Relaxed);
+    }
+
+    fn est_size(&self) -> usize {
+        self.est_size.load(Ordering::Relaxed)
+    }
+
+    fn set_dirty(&self, dirty: bool) {
+        self.is_dirty.store(dirty, Ordering::Release);
+    }
+
+    fn immut_lsn(&self) -> LSN {
+        0
+    }
+
+    fn notify_write(
+        &self,
+        _mem_segment: &mut RwLockWriteGuard<'_, MemGraphPropSegment>,
+    ) -> Result<(), StorageError> {
+        Ok(())
+    }
+
+    fn flush(&self) -> Result<(), StorageError> {
+        Ok(())
+    }
+}
diff --git a/db4-storage/src/segments/graph_prop/segment.rs b/db4-storage/src/segments/graph_prop/segment.rs
new file mode 100644
index 0000000000..a0d5eb6d28
--- /dev/null
+++ b/db4-storage/src/segments/graph_prop/segment.rs
@@ -0,0 +1,162 @@
+use crate::{
+    error::StorageError,
+    segments::{HasRow, SegmentContainer},
+    wal::LSN,
+};
+use raphtory_api::core::entities::{
+    LayerId,
+    properties::{
+        meta::Meta,
+        prop::{AsPropRef, Prop},
+    },
+};
+use raphtory_core::{
+    entities::properties::tprop::TPropCell,
+    storage::timeindex::{AsTime, EventTime},
+};
+use std::sync::Arc;
+
+/// In-memory segment that contains graph temporal properties and graph metadata.
+#[derive(Debug)]
+pub struct MemGraphPropSegment {
+    /// Layers containing graph properties and metadata.
+    layers: Vec<SegmentContainer<UnitEntry>>,
+    lsn: LSN,
+}
+
+/// A unit-like struct for use with `SegmentContainer`.
+/// Graph properties and metadata are already stored in `SegmentContainer`,
+/// hence this struct is empty.
+#[derive(Debug, Default)]
+pub struct UnitEntry(usize);
+
+// UnitEntry does not store data, but HasRow has to be implemented
+// for SegmentContainer to work.
+impl HasRow for UnitEntry {
+    fn row(&self) -> usize {
+        self.0
+    }
+
+    fn row_mut(&mut self) -> &mut usize {
+        &mut self.0
+    }
+}
+
+impl MemGraphPropSegment {
+    /// Graph segments only have a single row.
+    pub const DEFAULT_ROW: usize = 0;
+
+    /// Graph segments are currently only written to a single layer.
+    pub const DEFAULT_LAYER: LayerId = LayerId(0);
+
+    pub fn new_with_meta(meta: Arc<Meta>) -> Self {
+        // Technically, these aren't used since there is always only one graph segment.
+        let segment_id = 0;
+        let max_page_len = 1;
+
+        Self {
+            layers: vec![SegmentContainer::new(segment_id, max_page_len, meta)],
+            lsn: 0,
+        }
+    }
+
+    pub fn get_or_create_layer(&mut self, layer_id: LayerId) -> &mut SegmentContainer<UnitEntry> {
+        let layer_id = layer_id.0;
+        if layer_id >= self.layers.len() {
+            let max_page_len = self.layers[0].max_page_len();
+            let segment_id = self.layers[0].segment_id();
+            let meta = self.layers[0].meta().clone();
+            self.layers.resize_with(layer_id + 1, || {
+                SegmentContainer::new(segment_id, max_page_len, meta.clone())
+            });
+        }
+        &mut self.layers[layer_id]
+    }
+
+    pub fn layers(&self) -> &Vec<SegmentContainer<UnitEntry>> {
+        &self.layers
+    }
+
+    pub fn layers_mut(&mut self) -> &mut Vec<SegmentContainer<UnitEntry>> {
+        &mut self.layers
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.layers.iter().all(|layer| layer.est_size() == 0)
+    }
+
+    /// Replaces this segment with an empty instance, returning the old segment
+    /// with its data.
+    ///
+    /// The new segment will have the same number of layers as the original.
+    pub fn take(&mut self) -> Self {
+        let layers = self.layers.iter_mut().map(|layer| layer.take()).collect();
+
+        Self {
+            layers,
+            lsn: self.lsn,
+        }
+    }
+
+    pub fn lsn(&self) -> LSN {
+        self.lsn
+    }
+
+    pub fn set_lsn(&mut self, lsn: LSN) {
+        self.lsn = lsn;
+    }
+
+    pub fn add_properties<T: AsTime, P: AsPropRef>(
+        &mut self,
+        t: T,
+        props: impl IntoIterator<Item = (usize, P)>,
+    ) -> usize {
+        let layer = self.get_or_create_layer(Self::DEFAULT_LAYER);
+        let est_size = layer.est_size();
+        let ts = EventTime::new(t.t(), t.i());
+
+        layer.reserve_local_row(Self::DEFAULT_ROW.into());
+        let mut prop_mut_entry = layer.properties_mut().get_mut_entry(Self::DEFAULT_ROW);
+        prop_mut_entry.append_t_props(ts, props);
+
+        let layer_est_size = layer.est_size();
+        layer_est_size - est_size
+    }
+
+    pub fn check_metadata<P: AsPropRef>(&self, props: &[(usize, P)]) -> Result<(), StorageError> {
+        if let Some(layer) = self.layers.get(Self::DEFAULT_LAYER.0) {
+            layer.check_metadata(Self::DEFAULT_ROW.into(), props)?;
+        }
+
+        Ok(())
+    }
+
+    pub fn update_metadata<P: AsPropRef>(
+        &mut self,
+        props: impl IntoIterator<Item = (usize, P)>,
+    ) -> usize {
+        let segment_container = self.get_or_create_layer(Self::DEFAULT_LAYER);
+        let est_size = segment_container.est_size();
+
+        let row = segment_container
+            .reserve_local_row(Self::DEFAULT_ROW.into())
+            .map(|a| a.row());
+        let row = row.inner();
+        let mut prop_mut_entry = segment_container.properties_mut().get_mut_entry(row);
+        prop_mut_entry.append_const_props(props);
+
+        let layer_est_size = segment_container.est_size();
+        // random estimate for constant properties
+        (layer_est_size - est_size) + 8
+    }
+
+    pub fn get_temporal_prop(&self, prop_id: usize) -> Option<TPropCell<'_>> {
+        let layer = &self.layers[Self::DEFAULT_LAYER.0];
+        layer.t_prop(Self::DEFAULT_ROW, prop_id)
+    }
+
+    pub fn get_metadata(&self, prop_id: usize) -> Option<Prop> {
+        let layer = &self.layers[Self::DEFAULT_LAYER.0];
+        layer.c_prop(Self::DEFAULT_ROW, prop_id)
+    }
+}
diff --git a/db4-storage/src/segments/mod.rs b/db4-storage/src/segments/mod.rs
new file mode 100644
index 0000000000..222c8b2d71
--- /dev/null
+++ b/db4-storage/src/segments/mod.rs
@@ -0,0 +1,418 @@
+use super::properties::{PropEntry, Properties};
+use crate::{LocalPOS, error::StorageError};
+use raphtory_api::core::{
+    entities::properties::{
+        meta::Meta,
+        prop::{AsPropRef, Prop},
+    },
+    storage::dict_mapper::MaybeNew,
+};
+use raphtory_core::{
+    entities::{
+        ELID,
+        properties::{tcell::TCell, tprop::TPropCell},
+    },
+    storage::timeindex::EventTime,
+};
+use rayon::prelude::*;
+use std::{
+    fmt::{Debug, Formatter},
+    iter,
+    sync::Arc,
+};
+
+pub mod edge;
+pub mod graph_prop;
+pub mod node;
+
+pub mod additions;
+
+pub type PageIndexT = u32;
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+struct PageIndexEntry(PageIndexT);
+
+impl Default for PageIndexEntry {
+    fn default() -> Self {
+        PageIndexEntry(PageIndexT::MAX)
+    }
+}
+
+impl PageIndexEntry {
+    fn index(self) -> Option<usize> {
+        (self.0 != PageIndexT::MAX).then_some(self.0 as usize)
+    }
+
+    fn is_filled(self) -> bool {
+        self.0 != PageIndexT::MAX
+    }
+}
+
+#[derive(Default)]
+struct PageIndex(Vec<PageIndexEntry>);
+
+impl PageIndex {
+    fn get(&self, pos: LocalPOS) -> Option<usize> {
+        self.0.get(pos.as_index()).and_then(|index| index.index())
+    }
+
+    fn set(&mut self, pos: LocalPOS, index: PageIndexEntry) {
+        let pos_index = pos.as_index();
+        if pos_index >= self.0.len() {
+            self.0.resize(pos_index + 1, PageIndexEntry::default());
+        }
+        self.0[pos_index] = index;
+    }
+
+    fn iter(&self) -> impl ExactSizeIterator<Item = Option<usize>> {
+        self.0.iter().map(|i| i.index())
+    }
+
+    fn filled_positions(&self) -> impl Iterator<Item = LocalPOS> {
+        self.0
+            .iter()
+            .enumerate()
+            .filter_map(|(i, p)| p.is_filled().then_some(LocalPOS::from(i)))
+    }
+
+    fn par_iter(&self) -> impl IndexedParallelIterator<Item = Option<usize>> {
+        self.0.par_iter().map(|i| i.index())
+    }
+}
+
+#[derive(Default)]
+struct SparseVec<T> {
+    index: PageIndex,
+    data: Vec<(LocalPOS, T)>,
+    max_local_pos: Option<LocalPOS>,
+}
+
+impl<T: Debug> Debug for SparseVec<T> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_list().entries(self.iter_filled()).finish()
+    }
+}
+
+impl<T> SparseVec<T> {
+    fn get(&self, pos: LocalPOS) -> Option<&T> {
+        self.index
+            .get(pos)
+            .and_then(|i| self.data.get(i).map(|(_, x)| x))
+    }
+
+    fn is_filled(&self, pos: LocalPOS) -> bool {
+        self.index.get(pos).is_some()
+    }
+
+    /// Iterator over filled positions.
+    ///
+    /// Note that this returns items in insertion order!
+    fn iter_filled(&self) -> impl Iterator<Item = (LocalPOS, &T)> {
+        self.data.iter().map(|(i, x)| (*i, x))
+    }
+
+    fn iter_all(&self) -> impl ExactSizeIterator<Item = Option<&T>> {
+        self.index.iter().map(|i| i.map(|i| &self.data[i].1))
+    }
+
+    fn max_local_pos(&self) -> Option<LocalPOS> {
+        self.max_local_pos
+    }
+
+    fn num_filled(&self) -> usize {
+        self.data.len()
+    }
+}
+
+impl<T: Send + Sync> SparseVec<T> {
+    /// Parallel iterator over filled positions.
+    ///
+    /// Note that this returns items in insertion order!
+    fn par_iter_filled(&self) -> impl IndexedParallelIterator<Item = (LocalPOS, &T)> {
+        self.data.par_iter().map(|(i, x)| (*i, x))
+    }
+    fn par_iter_all(&self) -> impl IndexedParallelIterator<Item = Option<&T>> {
+        self.index.par_iter().map(|i| i.map(|i| &self.data[i].1))
+    }
+}
+
+impl<T: HasRow> SparseVec<T> {
+    fn get_or_new(&mut self, pos: LocalPOS) -> MaybeNew<&mut T> {
+        match self.index.get(pos) {
+            None => {
+                let next_index = self.data.len();
+                self.data.push((pos, T::default()));
+                let new_entry = &mut self.data[next_index].1;
+                *new_entry.row_mut() = next_index;
+                self.index.set(pos, PageIndexEntry(next_index as u32));
+                self.max_local_pos = self.max_local_pos.max(Some(pos));
+                MaybeNew::New(new_entry)
+            }
+            Some(i) => MaybeNew::Existing(&mut self.data[i].1),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SegmentContainer<T> {
+    segment_id: usize,
+    data: SparseVec<T>,
+    max_page_len: u32,
+    properties: Properties,
+    meta: Arc<Meta>,
+}
+
+pub trait HasRow: Default + Send + Sync + Sized {
+    fn row(&self) -> usize;
+
+    fn row_mut(&mut self) -> &mut usize;
+}
+
+impl<T: HasRow> SegmentContainer<T> {
+    pub fn new(segment_id: usize, max_page_len: u32, meta: Arc<Meta>) -> Self {
+        assert!(max_page_len > 0, "max_page_len must be greater than 0");
+
+        Self {
+            segment_id,
+            data: Default::default(),
+            max_page_len,
+            properties: Default::default(),
+            meta,
+        }
+    }
+
+    /// Replaces this container with an empty instance, returning the
+    /// old container with its data.
+    pub fn take(&mut self) -> Self {
+        std::mem::replace(
+            self,
+            Self::new(self.segment_id, self.max_page_len, self.meta.clone()),
+        )
+    }
+
+    #[inline]
+    pub fn est_size(&self) -> usize {
+        // TODO: this is a rough estimate and should be improved
+        let data_size =
+            (self.data.num_filled() as f64 * std::mem::size_of::<T>() as f64 * 1.5) as usize; // Estimate size of data
+        let timestamp_size = std::mem::size_of::<EventTime>();
+        (self.properties.additions_count * timestamp_size)
+            + data_size
+            + self.t_prop_est_size()
+            + self.c_prop_est_size()
+    }
+
+    pub fn get(&self, item_pos: LocalPOS) -> Option<&T> {
+        self.data.get(item_pos)
+    }
+
+    pub fn has_item(&self, item_pos: LocalPOS) -> bool {
+        self.data.is_filled(item_pos)
+    }
+
+    pub fn max_page_len(&self) -> u32 {
+        self.max_page_len
+    }
+
+    pub fn max_rows(&self) -> usize {
+        self.data.max_local_pos().map(|pos| pos.0 + 1).unwrap_or(0) as usize
+    }
+
+    pub fn is_full(&self) -> bool {
+        self.data.num_filled() == self.max_page_len() as usize
+    }
+
+    pub fn t_len(&self) -> usize {
+        self.properties.t_len()
+    }
+
+    /// Reserves a local row for the given item position.
+    /// If the item position already exists, it returns a mutable reference to the existing item.
+    /// Left variant indicates that the item was already present,
+    /// Right variant indicates that a new item was created.
+    pub(crate) fn reserve_local_row(&mut self, item_pos: LocalPOS) -> MaybeNew<&mut T> {
+        self.data.get_or_new(item_pos)
+    }
+
+    #[inline]
+    pub fn t_prop_est_size(&self) -> usize {
+        let row_size = self.meta.temporal_est_row_size();
+        let row_count = self.properties.t_len();
+
+        row_size * row_count
+    }
+
+    pub(crate) fn c_prop_est_size(&self) -> usize {
+        self.meta.const_est_row_size() * self.len() as usize
+    }
+
+    pub fn properties(&self) -> &Properties {
+        &self.properties
+    }
+
+    pub fn properties_mut(&mut self) -> &mut Properties {
+        &mut self.properties
+    }
+
+    pub fn check_metadata<P: AsPropRef>(
+        &self,
+        local_pos: LocalPOS,
+        props: &[(usize, P)],
+    ) -> Result<(), StorageError> {
+        if let Some(item) = self.get(local_pos) {
+            let local_row = item.row();
+            let prop_entry = self.properties().get_entry(local_row);
+
+            for (prop_id, prop_val) in props {
+                prop_entry.check_metadata(*prop_id, prop_val.as_prop_ref())?;
+            }
+        }
+
+        Ok(())
+    }
+
+    pub fn meta(&self) -> &Arc<Meta> {
+        &self.meta
+    }
+
+    pub fn filled_positions(&self) -> impl Iterator<Item = LocalPOS> {
+        self.data.index.filled_positions()
+    }
+
+    pub fn filled_positions_par(&self) -> impl ParallelIterator<Item = LocalPOS> {
+        self.data.par_iter_filled().map(|(i, _)| i)
+    }
+
+    #[inline(always)]
+    pub fn segment_id(&self) -> usize {
+        self.segment_id
+    }
+
+    pub fn len(&self) -> u32 {
+        self.data.data.len() as u32
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.data.data.is_empty()
+    }
+
+    /// returns items in insertion order!
+    pub fn row_entries(&self) -> impl Iterator<Item = (LocalPOS, &T, PropEntry<'_>)> {
+        self.data
+            .iter_filled()
+            .map(|(l_pos, entry)| (l_pos, entry, self.properties().get_entry(entry.row())))
+    }
+
+    /// return filled entries ordered by index
+    pub fn row_entries_ordered(&self) -> impl Iterator<Item = (LocalPOS, &T, PropEntry<'_>)> {
+        self.all_entries().filter_map(|(pos, entry)| {
+            let (v, row) = entry?;
+            Some((pos, v, row))
+        })
+    }
+
+    pub fn all_entries(&self) -> impl Iterator<Item = (LocalPOS, Option<(&T, PropEntry<'_>)>)> {
+        let max_local_pos = self.data.max_local_pos().map(|p| p.0 as usize).unwrap_or(0);
+        self.data
+            .iter_all()
+            .chain(iter::repeat(None))
+            .take(max_local_pos + 1)
+            .enumerate()
+            .map(|(i, v)| {
+                (
+                    LocalPOS::from(i),
+                    v.map(|v| (v, self.properties().get_entry(v.row()))),
+                )
+            })
+    }
+
+    pub fn all_entries_par(
+        &self,
+    ) -> impl ParallelIterator<Item = (LocalPOS, Option<(&T, PropEntry<'_>)>)> + '_ {
+        self.data.par_iter_all().enumerate().map(|(i, v)| {
+            (
+                LocalPOS::from(i),
+                v.map(|entry| (entry, self.properties().get_entry(entry.row()))),
+            )
+        })
+    }
+
+    pub fn earliest(&self) -> Option<EventTime> {
+        self.properties.earliest()
+    }
+
+    pub fn latest(&self) -> Option<EventTime> {
+        self.properties.latest()
+    }
+
+    pub fn temporal_index(&self) -> Vec<usize> {
+        self.row_entries_ordered()
+            .flat_map(|(_, mp, _)| {
+                let row = mp.row();
+                self.properties()
+                    .times_from_props(row)
+                    .into_iter()
+                    .flat_map(|entry| entry.iter())
+                    .filter_map(|(_, &v)| v)
+            })
+            .collect::<Vec<_>>()
+    }
+
+    pub fn t_prop(&self, item_id: impl Into<LocalPOS>, prop_id: usize) -> Option<TPropCell<'_>> {
+        let item_id = item_id.into();
+        self.data.get(item_id).and_then(|entry| {
+            let prop_entry = self.properties.get_entry(entry.row());
+            prop_entry.prop(prop_id)
+        })
+    }
+
+    pub fn t_prop_rows(&self, item_id: impl Into<LocalPOS>) -> &TCell<Option<usize>> {
+        let item_id = item_id.into();
+        self.data
+            .get(item_id)
+            .map(|entry| {
+                let prop_entry = self.properties.get_entry(entry.row());
+                prop_entry.t_cell()
+            })
+            .unwrap_or(&TCell::Empty)
+    }
+
+    pub fn c_prop(&self, item_id: impl Into<LocalPOS>, prop_id: usize) -> Option<Prop> {
+        let item_id = item_id.into();
+        self.data.get(item_id).and_then(|entry| {
+            let prop_entry = self.properties.c_column(prop_id)?;
+            prop_entry.get(entry.row())
+        })
+    }
+
+    pub fn c_prop_str(&self, item_id: impl Into<LocalPOS>, prop_id: usize) -> Option<&str> {
+        let item_id = item_id.into();
+        self.data.get(item_id).and_then(|entry| {
+            let prop_entry = self.properties.c_column(prop_id)?;
+            prop_entry
+                .get_ref(entry.row())
+                .and_then(|prop| prop.as_str())
+        })
+    }
+
+    pub fn additions(&self, item_pos: LocalPOS) -> &TCell<ELID> {
+        self.data
+            .get(item_pos)
+            .and_then(|entry| self.properties.additions(entry.row()))
+            .unwrap_or(&TCell::Empty)
+    }
+
+    pub fn deletions(&self, item_pos: LocalPOS) -> &TCell<ELID> {
+        self.data
+            .get(item_pos)
+            .and_then(|entry| self.properties.deletions(entry.row()))
+            .unwrap_or(&TCell::Empty)
+    }
+
+    pub fn times_from_props(&self, item_pos: LocalPOS) -> &TCell<Option<usize>> {
+        self.data
+            .get(item_pos)
+            .and_then(|entry| self.properties.times_from_props(entry.row()))
+            .unwrap_or(&TCell::Empty)
+    }
+}
diff --git a/db4-storage/src/segments/node/entry.rs b/db4-storage/src/segments/node/entry.rs
new file mode 100644
index 0000000000..7d0bc872f0
--- /dev/null
+++ b/db4-storage/src/segments/node/entry.rs
@@ -0,0 +1,264 @@
+use crate::{
+    LocalPOS, NodeEdgeAdditions, NodePropAdditions, NodeTProps,
+    api::nodes::{NodeEntryOps, NodeRefOps},
+    gen_ts::{EdgeAdditionCellsRef, LayerIter, PropAdditionCellsRef, WithTimeCells},
+    generic_t_props::WithTProps,
+    segments::{additions::MemAdditions, node::segment::MemNodeSegment},
+};
+use itertools::Itertools;
+use raphtory_api::core::{
+    Direction,
+    entities::{
+        EID, LayerId, VID,
+        properties::{
+            meta::{Meta, STATIC_GRAPH_LAYER_ID},
+            prop::Prop,
+        },
+    },
+};
+use raphtory_core::{
+    entities::{LayerIds, edges::edge_ref::EdgeRef, properties::tprop::TPropCell},
+    storage::timeindex::{EventTime, TimeIndexOps},
+};
+use std::{ops::Deref, sync::Arc};
+
+pub struct MemNodeEntry<'a, MNS> {
+    pos: LocalPOS,
+    ns: MNS,
+    __marker: std::marker::PhantomData<&'a ()>,
+}
+
+impl<'a, MNS: Deref<Target = MemNodeSegment>> MemNodeEntry<'a, MNS> {
+    pub fn new(pos: LocalPOS, ns: MNS) -> Self {
+        Self {
+            pos,
+            ns,
+            __marker: std::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, MNS: Deref<Target = MemNodeSegment> + Send + Sync + 'a> NodeEntryOps<'a>
+    for MemNodeEntry<'a, MNS>
+{
+    type Ref<'b>
+        = MemNodeRef<'b>
+    where
+        'a: 'b,
+        MNS: 'b;
+
+    fn as_ref<'b>(&'b self) -> Self::Ref<'b>
+    where
+        'a: 'b,
+    {
+        MemNodeRef {
+            pos: self.pos,
+            ns: self.ns.deref(),
+        }
+    }
+}
+
+#[derive(Copy, Clone, Debug)]
+pub struct MemNodeRef<'a> {
+    pos: LocalPOS,
+    ns: &'a MemNodeSegment,
+}
+
+impl<'a> MemNodeRef<'a> {
+    pub fn new(pos: LocalPOS, ns: &'a MemNodeSegment) -> Self {
+        Self { pos, ns }
+    }
+}
+
+impl<'a> WithTimeCells<'a> for MemNodeRef<'a> {
+    type TimeCell = MemAdditions<'a>;
+
+    fn t_props_tc(
+        self,
+        layer_id: LayerId,
+        range: Option<(EventTime, EventTime)>,
+    ) -> impl Iterator<Item = Self::TimeCell> + 'a {
+        self.ns
+            .as_ref()
+            .get(layer_id.0)
+            .map(|seg| MemAdditions::Props(seg.times_from_props(self.pos)))
+            .into_iter()
+            .map(move |t_cell| {
+                range
+                    .map(|(start, end)| t_cell.range(start..end))
+                    .unwrap_or_else(|| t_cell)
+            })
+    }
+
+    fn additions_tc(
+        self,
+        layer_id: LayerId,
+        range: Option<(EventTime, EventTime)>,
+    ) -> impl Iterator<Item = Self::TimeCell> + 'a {
+        self.ns
+            .as_ref()
+            .get(layer_id.0)
+            .map(|seg| MemAdditions::Edges(seg.additions(self.pos)))
+            .into_iter()
+            .map(move |t_cell| {
+                range
+                    .map(|(start, end)| t_cell.range(start..end))
+                    .unwrap_or_else(|| t_cell)
+            })
+    }
+
+    fn deletions_tc(
+        self,
+        layer_id: LayerId,
+        range: Option<(EventTime, EventTime)>,
+    ) -> impl Iterator<Item = Self::TimeCell> + 'a {
+        self.ns
+            .as_ref()
+            .get(layer_id.0)
+            .map(|seg| MemAdditions::Edges(seg.deletions(self.pos)))
+            .into_iter()
+            .map(move |t_cell| {
+                range
+                    .map(|(start, end)| t_cell.range(start..end))
+                    .unwrap_or_else(|| t_cell)
+            })
+    }
+
+    fn num_layers(&self) -> usize {
+        self.ns.as_ref().len()
+    }
+}
+
+impl<'a> WithTProps<'a> for MemNodeRef<'a> {
+    type TProp = TPropCell<'a>;
+
+    fn num_layers(&self) -> usize {
+        self.ns.as_ref().len()
+    }
+
+    fn into_t_props(
+        self,
+        layer_id: LayerId,
+        prop_id: usize,
+    ) -> impl Iterator<Item = Self::TProp> + 'a {
+        let node_pos = self.pos;
+        self.ns
+            .as_ref()
+            .get(layer_id.0)
+            .and_then(|layer| layer.t_prop(node_pos, prop_id))
+            .into_iter()
+    }
+}
+
+impl<'a> NodeRefOps<'a> for MemNodeRef<'a> {
+    type Additions = NodePropAdditions<'a>;
+    type EdgeAdditions = NodeEdgeAdditions<'a>;
+    type TProps = NodeTProps<'a>;
+
+    fn node_meta(&self) -> &Arc<Meta> {
+        self.ns.node_meta()
+    }
+
+    fn vid(&self) -> VID {
+        self.ns.to_vid(self.pos)
+    }
+
+    fn out_edges(self, layer_id: LayerId) -> impl Iterator<Item = (VID, EID)> + 'a {
+        self.ns.out_edges(self.pos, layer_id)
+    }
+
+    fn inb_edges(self, layer_id: LayerId) -> impl Iterator<Item = (VID, EID)> + 'a {
+        self.ns.inb_edges(self.pos, layer_id)
+    }
+
+    fn out_edges_sorted(self, layer_id: LayerId) -> impl Iterator<Item = (VID, EID)> + 'a {
+        self.ns.out_edges(self.pos, layer_id)
+    }
+
+    fn inb_edges_sorted(self, layer_id: LayerId) -> impl Iterator<Item = (VID, EID)> + 'a {
+        self.ns.inb_edges(self.pos, layer_id)
+    }
+
+    fn c_prop(self, layer_id: LayerId, prop_id: usize) -> Option<Prop> {
+        self.ns
+            .as_ref()
+            .get(layer_id.0)
+            .and_then(|layer| layer.c_prop(self.pos, prop_id))
+    }
+
+    fn c_prop_str(self, layer_id: LayerId, prop_id: usize) -> Option<&'a str> {
+        self.ns
+            .as_ref()
+            .get(layer_id.0)
+            .and_then(|layer| layer.c_prop_str(self.pos, prop_id))
+    }
+
+    fn node_additions<L: Into<LayerIter<'a>>>(self, layer_id: L) -> Self::Additions {
+        NodePropAdditions::new_with_layer(PropAdditionCellsRef::new(self), layer_id)
+    }
+
+    fn edge_additions<L: Into<LayerIter<'a>>>(self, layer_id: L) -> Self::EdgeAdditions {
+        NodeEdgeAdditions::new_with_layer(EdgeAdditionCellsRef::new(self), layer_id)
+    }
+
+    fn degree(self, layers: &LayerIds, dir: Direction) -> usize {
+        match layers {
+            LayerIds::One(layer_id) => self.ns.degree(self.pos, *layer_id, dir),
+            LayerIds::All => self.ns.degree(self.pos, STATIC_GRAPH_LAYER_ID, dir),
+            LayerIds::None => 0,
+            LayerIds::Multiple(ids) => match dir {
+                Direction::OUT => ids
+                    .iter()
+                    .map(|id| self.out_nbrs_sorted(id))
+                    .kmerge()
+                    .dedup()
+                    .count(),
+                Direction::IN => ids
+                    .iter()
+                    .map(|id| self.inb_nbrs_sorted(id))
+                    .kmerge()
+                    .dedup()
+                    .count(),
+                Direction::BOTH => ids
+                    .iter()
+                    .map(|id| {
+                        self.out_nbrs_sorted(id)
+                            .merge(self.inb_nbrs_sorted(id))
+                            .dedup()
+                    })
+                    .kmerge()
+                    .dedup()
+                    .count(),
+            },
+        }
+    }
+
+    fn find_edge(&self, dst: VID, layers: &LayerIds) -> Option<EdgeRef> {
+        let eid = match layers {
+            LayerIds::One(layer_id) => self.ns.get_out_edge(self.pos, dst, *layer_id),
+            LayerIds::All => self.ns.get_out_edge(self.pos, dst, STATIC_GRAPH_LAYER_ID),
+            LayerIds::Multiple(layers) => layers
+                .iter()
+                .find_map(|layer_id| self.ns.get_out_edge(self.pos, dst, layer_id)),
+            LayerIds::None => None,
+        };
+
+        let src_id = self.ns.to_vid(self.pos);
+        eid.map(|eid| EdgeRef::new_outgoing(eid, src_id, dst))
+    }
+
+    fn temporal_prop_layer(self, layer_id: LayerId, prop_id: usize) -> Self::TProps {
+        NodeTProps::new_with_layer(self, layer_id, prop_id)
+    }
+
+    fn internal_num_layers(&self) -> usize {
+        self.ns.as_ref().len()
+    }
+
+    fn has_layer_inner(self, layer_id: LayerId) -> bool {
+        self.ns
+            .as_ref()
+            .get(layer_id.0)
+            .is_some_and(|layer| layer.has_item(self.pos))
+    }
+}
diff --git a/db4-storage/src/segments/node/mod.rs b/db4-storage/src/segments/node/mod.rs
new file mode 100644
index 0000000000..d0b743bd85
--- /dev/null
+++ b/db4-storage/src/segments/node/mod.rs
@@ -0,0 +1,2 @@
+pub mod entry;
+pub mod segment;
diff --git a/db4-storage/src/segments/node/segment.rs b/db4-storage/src/segments/node/segment.rs
new file mode 100644
index 0000000000..a0354bc8a8
--- /dev/null
+++ b/db4-storage/src/segments/node/segment.rs
@@ -0,0 +1,756 @@
+use crate::{
+    LocalPOS,
+    api::nodes::{LockedNSSegment, NodeSegmentOps},
+    error::StorageError,
+    loop_lock_write,
+    persist::{config::ConfigOps, strategy::PersistenceStrategy},
+    segments::{
+        HasRow, SegmentContainer,
+        node::entry::{MemNodeEntry, MemNodeRef},
+    },
+    wal::LSN,
+};
+use either::Either;
+use parking_lot::{RwLock, lock_api::ArcRwLockReadGuard};
+use raphtory_api::core::{
+    Direction,
+    entities::{
+        EID, LayerId, VID,
+        properties::{
+            meta::Meta,
+            prop::{AsPropRef, Prop},
+        },
+    },
+};
+use raphtory_core::{
+    entities::{ELID, nodes::structure::adj::Adj},
+    storage::timeindex::{AsTime, EventTime},
+};
+use std::{
+    ops::{Deref, DerefMut},
+    path::PathBuf,
+    sync::{
+        Arc,
+        atomic::{AtomicU32, AtomicUsize, Ordering},
+    },
+};
+
+#[derive(Debug)]
+pub struct MemNodeSegment {
+    segment_id: usize,
+    max_page_len: u32,
+    layers: Vec<SegmentContainer<AdjEntry>>,
+    global_mem_tracker: Arc<AtomicUsize>,
+    est_size: usize,
+    lsn: LSN,
+}
+
+impl Drop for MemNodeSegment {
+    fn drop(&mut self) {
+        self.global_mem_tracker
+            .fetch_sub(self.est_size, Ordering::Relaxed);
+    }
+}
+
+#[derive(Debug, Default, serde::Serialize)]
+pub struct AdjEntry {
+    row: usize,
+    adj: Adj,
+}
+
+impl AdjEntry {
+    pub fn degree(&self, d: Direction) -> usize {
+        self.adj.degree(d)
+    }
+
+    pub fn edges(&self, d: Direction) -> impl Iterator<Item = (VID, EID)> + '_ {
+        match d {
+            Direction::IN => Either::Left(self.adj.inb_iter()),
+            Direction::OUT => Either::Right(self.adj.out_iter()),
+            Direction::BOTH => panic!("AdjEntry::edges: BOTH direction is not supported"),
+        }
+    }
+}
+
+impl HasRow for AdjEntry {
+    fn row(&self) -> usize {
+        self.row
+    }
+
+    fn row_mut(&mut self) -> &mut usize {
+        &mut self.row
+    }
+}
+
+impl AsRef<[SegmentContainer<AdjEntry>]> for MemNodeSegment {
+    fn as_ref(&self) -> &[SegmentContainer<AdjEntry>] {
+        &self.layers
+    }
+}
+
+impl AsMut<[SegmentContainer<AdjEntry>]> for MemNodeSegment {
+    fn as_mut(&mut self) -> &mut [SegmentContainer<AdjEntry>] {
+        &mut self.layers
+    }
+}
+
+impl MemNodeSegment {
+    pub fn segment_id(&self) -> usize {
+        self.segment_id
+    }
+
+    pub fn est_size(&self) -> usize {
+        self.est_size
+    }
+
+    pub(crate) fn increment_global_est_size(&self, increment: usize) {
+        self.global_mem_tracker
+            .fetch_add(increment, Ordering::Relaxed);
+    }
+
+    pub(crate) fn increment_est_size(&mut self, increment: usize) {
+        self.est_size += increment;
+    }
+
+    pub fn swap_out_layers(&mut self) -> Vec<SegmentContainer<AdjEntry>> {
+        self.layers
+            .iter_mut()
+            .map(|head_guard| {
+                let mut old_head = SegmentContainer::new(
+                    head_guard.segment_id(),
+                    head_guard.max_page_len(),
+                    head_guard.meta().clone(),
+                );
+                std::mem::swap(&mut *head_guard, &mut old_head);
+                old_head
+            })
+            .collect::<Vec<_>>()
+    }
+
+    pub fn get_or_create_layer(&mut self, layer_id: LayerId) -> &mut SegmentContainer<AdjEntry> {
+        let layer_id = layer_id.0;
+        if layer_id >= self.layers.len() {
+            let max_page_len = self.layers[0].max_page_len();
+            let segment_id = self.layers[0].segment_id();
+            let meta = self.layers[0].meta().clone();
+
+            self.layers.resize_with(layer_id + 1, || {
+                SegmentContainer::new(segment_id, max_page_len, meta.clone())
+            });
+        }
+
+        &mut self.layers[layer_id]
+    }
+
+    pub fn node_meta(&self) -> &Arc<Meta> {
+        self.layers[0].meta()
+    }
+
+    pub fn get_layer(&self, layer_id: LayerId) -> Option<&SegmentContainer<AdjEntry>> {
+        self.layers.get(layer_id.0)
+    }
+
+    pub fn degree(&self, n: LocalPOS, layer_id: LayerId, dir: Direction) -> usize {
+        self.get_adj(n, layer_id).map_or(0, |adj| adj.degree(dir))
+    }
+
+    pub fn lsn(&self) -> LSN {
+        self.lsn
+    }
+
+    pub fn set_lsn(&mut self, lsn: LSN) {
+        if lsn > self.lsn {
+            self.lsn = lsn;
+        }
+    }
+
+    /// Replaces this segment with an empty instance, returning the old segment
+    /// with its data.
+    ///
+    /// The new segment will have the same number of layers as the original.
+    pub fn take(&mut self) -> Self {
+        let layers = self.layers.iter_mut().map(|layer| layer.take()).collect();
+        let est_size = self.est_size;
+        self.est_size = 0;
+        Self {
+            segment_id: self.segment_id,
+            max_page_len: self.max_page_len,
+            est_size,
+            global_mem_tracker: self.global_mem_tracker.clone(),
+            layers,
+            lsn: self.lsn,
+        }
+    }
+
+    pub fn to_vid(&self, pos: LocalPOS) -> VID {
+        pos.as_vid(self.segment_id, self.max_page_len)
+    }
+
+    #[inline(always)]
+    fn get_adj(&self, n: LocalPOS, layer_id: LayerId) -> Option<&Adj> {
+        let layer_id = layer_id.0;
+        self.layers
+            .get(layer_id)?
+            .get(n)
+            .map(|AdjEntry { adj, .. }| adj)
+    }
+
+    pub fn has_node(&self, n: LocalPOS, layer_id: LayerId) -> bool {
+        let layer_id = layer_id.0;
+        self.layers
+            .get(layer_id)
+            .is_some_and(|layer| layer.has_item(n))
+    }
+
+    pub fn get_out_edge(&self, n: LocalPOS, dst: VID, layer_id: LayerId) -> Option<EID> {
+        self.get_adj(n, layer_id)
+            .and_then(|adj| adj.get_edge(dst, Direction::OUT))
+    }
+
+    pub fn get_inb_edge(&self, n: LocalPOS, src: VID, layer_id: LayerId) -> Option<EID> {
+        self.get_adj(n, layer_id)
+            .and_then(|adj| adj.get_edge(src, Direction::IN))
+    }
+
+    pub fn out_edges(
+        &self,
+        n: LocalPOS,
+        layer_id: LayerId,
+    ) -> impl Iterator<Item = (VID, EID)> + '_ {
+        self.get_adj(n, layer_id)
+            .into_iter()
+            .flat_map(|adj| adj.out_iter())
+    }
+
+    pub fn inb_edges(
+        &self,
+        n: LocalPOS,
+        layer_id: LayerId,
+    ) -> impl Iterator<Item = (VID, EID)> + '_ {
+        self.get_adj(n, layer_id)
+            .into_iter()
+            .flat_map(|adj| adj.inb_iter())
+    }
+
+    pub fn new(
+        segment_id: usize,
+        max_page_len: u32,
+        meta: Arc<Meta>,
+        global_mem_tracker: Arc<AtomicUsize>,
+    ) -> Self {
+        Self {
+            segment_id,
+            max_page_len,
+            layers: vec![SegmentContainer::new(segment_id, max_page_len, meta)],
+            global_mem_tracker,
+            est_size: 0,
+            lsn: 0,
+        }
+    }
+
+    pub fn add_outbound_edge<T: AsTime>(
+        &mut self,
+        t: Option<T>,
+        src_pos: LocalPOS,
+        dst: impl Into<VID>,
+        e_id: impl Into<ELID>,
+    ) -> (bool, usize) {
+        let dst = dst.into();
+        let e_id = e_id.into();
+        let layer_id = e_id.layer();
+        let layer = self.get_or_create_layer(layer_id);
+        let est_size = layer.est_size();
+
+        let add_out = layer.reserve_local_row(src_pos);
+        let new_entry = add_out.is_new();
+        let add_out = add_out.inner();
+        let is_new_edge = add_out.adj.add_edge_out(dst, e_id.edge);
+        let row = add_out.row;
+        if let Some(t) = t {
+            self.update_timestamp_inner(t, row, e_id);
+        }
+        let layer_est_size = self.layers[layer_id.0].est_size();
+        let added_size = (layer_est_size - est_size)
+            + (is_new_edge as usize * std::mem::size_of::<(VID, VID)>());
+        (new_entry, added_size)
+    }
+
+    pub fn add_inbound_edge(
+        &mut self,
+        t: Option<impl AsTime>,
+        dst_pos: impl Into<LocalPOS>,
+        src: impl Into<VID>,
+        e_id: impl Into<ELID>,
+    ) -> (bool, usize) {
+        let src = src.into();
+        let e_id = e_id.into();
+        let layer_id = e_id.layer();
+        let dst_pos = dst_pos.into();
+
+        let layer = self.get_or_create_layer(layer_id);
+        let est_size = layer.est_size();
+
+        let add_in = layer.reserve_local_row(dst_pos);
+        let new_entry = add_in.is_new();
+        let add_in = add_in.inner();
+        let is_new_edge = add_in.adj.add_edge_into(src, e_id.edge);
+        let row = add_in.row;
+
+        if let Some(t) = t {
+            self.update_timestamp_inner(t, row, e_id);
+        }
+        let layer_est_size = self.layers[layer_id.0].est_size();
+        let added_size = (layer_est_size - est_size)
+            + (is_new_edge as usize * std::mem::size_of::<(VID, VID)>());
+        (new_entry, added_size)
+    }
+
+    fn update_timestamp_inner<T: AsTime>(&mut self, t: T, row: usize, e_id: ELID) {
+        let mut prop_mut_entry = self.layers[e_id.layer().0]
+            .properties_mut()
+            .get_mut_entry(row);
+        let ts = EventTime::new(t.t(), t.i());
+
+        prop_mut_entry.addition_timestamp(ts, e_id);
+    }
+
+    pub fn update_timestamp<T: AsTime>(&mut self, t: T, node_pos: LocalPOS, e_id: ELID) -> usize {
+        let layer_id = e_id.layer();
+        let (est_size, row) = {
+            let segment_container = self.get_or_create_layer(layer_id); //&mut self.layers[e_id.layer()];
+            let est_size = segment_container.est_size();
+            let row = segment_container.reserve_local_row(node_pos).inner().row();
+            (est_size, row)
+        };
+        self.update_timestamp_inner(t, row, e_id);
+        let layer_est_size = self.layers[layer_id.0].est_size();
+        layer_est_size - est_size
+    }
+
+    pub fn add_props<T: AsTime, P: AsPropRef>(
+        &mut self,
+        t: T,
+        node_pos: LocalPOS,
+        layer_id: LayerId,
+        props: impl IntoIterator<Item = (usize, P)>,
+    ) -> (bool, usize) {
+        let layer = self.get_or_create_layer(layer_id);
+        let est_size = layer.est_size();
+        let row = layer.reserve_local_row(node_pos);
+        let is_new = row.is_new();
+        let row = row.inner().row;
+        let mut prop_mut_entry = layer.properties_mut().get_mut_entry(row);
+        let ts = EventTime::new(t.t(), t.i());
+        prop_mut_entry.append_t_props(ts, props);
+        let layer_est_size = layer.est_size();
+        (is_new, layer_est_size - est_size)
+    }
+
+    pub fn check_metadata<P: AsPropRef>(
+        &self,
+        node_pos: LocalPOS,
+        layer_id: LayerId,
+        props: &[(usize, P)],
+    ) -> Result<(), StorageError> {
+        if let Some(layer) = self.layers.get(layer_id.0) {
+            layer.check_metadata(node_pos, props)?;
+        }
+        Ok(())
+    }
+
+    pub fn update_metadata<P: AsPropRef>(
+        &mut self,
+        node_pos: LocalPOS,
+        layer_id: LayerId,
+        props: impl IntoIterator<Item = (usize, P)>,
+    ) -> (bool, usize) {
+        let segment_container = self.get_or_create_layer(layer_id);
+        let est_size = segment_container.est_size();
+
+        let row = segment_container.reserve_local_row(node_pos).map(|a| a.row);
+        let is_new = row.is_new();
+        let row = row.inner();
+        let mut prop_mut_entry = segment_container.properties_mut().get_mut_entry(row);
+        prop_mut_entry.append_const_props(props);
+
+        let layer_est_size = segment_container.est_size();
+        let added_size = (layer_est_size - est_size) + 8; // random estimate for constant properties
+        (is_new, added_size)
+    }
+
+    pub fn get_metadata(
+        &self,
+        node_pos: LocalPOS,
+        layer_id: LayerId,
+        prop_id: usize,
+    ) -> Option<Prop> {
+        let segment_container = &self.layers[layer_id.0];
+        segment_container.c_prop(node_pos, prop_id)
+    }
+
+    pub fn latest(&self) -> Option<EventTime> {
+        Iterator::max(self.layers.iter().filter_map(|seg| seg.latest()))
+    }
+
+    pub fn earliest(&self) -> Option<EventTime> {
+        Iterator::min(self.layers.iter().filter_map(|seg| seg.earliest()))
+    }
+
+    pub fn t_len(&self) -> usize {
+        self.layers.iter().map(|seg| seg.t_len()).sum()
+    }
+
+    pub fn node_ref(&self, pos: LocalPOS) -> MemNodeRef<'_> {
+        MemNodeRef::new(pos, self)
+    }
+
+    pub fn max_page_len(&self) -> u32 {
+        self.max_page_len
+    }
+}
+
+#[derive(Debug)]
+pub struct NodeSegmentView<EXT> {
+    inner: Arc<RwLock<MemNodeSegment>>,
+    segment_id: usize,
+    max_num_node: AtomicU32,
+    _ext: EXT,
+}
+
+#[derive(Debug)]
+pub struct ArcLockedSegmentView {
+    inner: ArcRwLockReadGuard<parking_lot::RawRwLock, MemNodeSegment>,
+    num_nodes: u32,
+}
+
+impl ArcLockedSegmentView {
+    pub fn new(
+        inner: ArcRwLockReadGuard<parking_lot::RawRwLock, MemNodeSegment>,
+        num_nodes: u32,
+    ) -> Self {
+        Self { inner, num_nodes }
+    }
+}
+
+impl LockedNSSegment for ArcLockedSegmentView {
+    type EntryRef<'a> = MemNodeRef<'a>;
+
+    fn num_nodes(&self) -> u32 {
+        self.num_nodes
+    }
+
+    fn entry_ref<'a>(&'a self, pos: impl Into<LocalPOS>) -> Self::EntryRef<'a> {
+        let pos = pos.into();
+        MemNodeRef::new(pos, &self.inner)
+    }
+}
+
+impl<P: PersistenceStrategy<NS = NodeSegmentView<P>>> NodeSegmentOps for NodeSegmentView<P> {
+    type Extension = P;
+
+    type Entry<'a> = MemNodeEntry<'a, parking_lot::RwLockReadGuard<'a, MemNodeSegment>>;
+
+    type ArcLockedSegment = ArcLockedSegmentView;
+
+    fn latest(&self) -> Option<EventTime> {
+        self.head().latest()
+    }
+
+    fn earliest(&self) -> Option<EventTime> {
+        self.head().latest()
+    }
+
+    fn t_len(&self) -> usize {
+        self.head().t_len()
+    }
+
+    fn load(
+        _segment_id: usize,
+        _node_meta: Arc<Meta>,
+        _edge_meta: Arc<Meta>,
+        _path: impl AsRef<std::path::Path>,
+        _ext: Self::Extension,
+    ) -> Result<Self, StorageError>
+    where
+        Self: Sized,
+    {
+        Err(StorageError::GenericFailure(
+            "load not supported".to_string(),
+        ))
+    }
+
+    fn new(
+        segment_id: usize,
+        meta: Arc<Meta>,
+        _edge_meta: Arc<Meta>,
+        _path: Option<PathBuf>,
+        ext: Self::Extension,
+    ) -> Self {
+        let max_page_len = ext.config().max_node_page_len();
+        let inner = RwLock::new(MemNodeSegment::new(
+            segment_id,
+            max_page_len,
+            meta,
+            ext.memory_tracker().clone(),
+        ));
+        let inner = Arc::new(inner);
+
+        Self {
+            inner,
+            segment_id,
+            _ext: ext,
+            max_num_node: AtomicU32::new(0),
+        }
+    }
+
+    fn segment_id(&self) -> usize {
+        self.segment_id
+    }
+
+    fn is_dirty(&self) -> bool {
+        true
+    }
+
+    #[inline(always)]
+    fn head_arc(&self) -> ArcRwLockReadGuard<parking_lot::RawRwLock, MemNodeSegment> {
+        self.inner.read_arc_recursive()
+    }
+
+    #[inline(always)]
+    fn head(&self) -> parking_lot::RwLockReadGuard<'_, MemNodeSegment> {
+        self.inner.read_recursive()
+    }
+
+    #[inline(always)]
+    fn head_mut(&self) -> parking_lot::RwLockWriteGuard<'_, MemNodeSegment> {
+        loop_lock_write(&self.inner)
+    }
+
+    #[inline(always)]
+    fn try_head_mut(&self) -> Option<parking_lot::RwLockWriteGuard<'_, MemNodeSegment>> {
+        self.inner.try_write()
+    }
+
+    fn notify_write(
+        &self,
+        _head_lock: impl DerefMut<Target = MemNodeSegment>,
+    ) -> Result<(), StorageError> {
+        Ok(())
+    }
+
+    fn set_dirty(&self, _dirty: bool) {}
+
+    fn has_node(&self, _pos: LocalPOS, _layer_id: LayerId) -> bool {
+        false
+    }
+
+    fn get_out_edge(
+        &self,
+        pos: LocalPOS,
+        dst: impl Into<VID>,
+        layer_id: LayerId,
+        locked_head: impl Deref<Target = MemNodeSegment>,
+    ) -> Option<EID> {
+        locked_head.get_out_edge(pos, dst.into(), layer_id)
+    }
+
+    fn get_inb_edge(
+        &self,
+        pos: LocalPOS,
+        src: impl Into<VID>,
+        layer_id: LayerId,
+        locked_head: impl Deref<Target = MemNodeSegment>,
+    ) -> Option<EID> {
+        locked_head.get_inb_edge(pos, src.into(), layer_id)
+    }
+
+    fn entry<'a>(&'a self, pos: impl Into<LocalPOS>) -> Self::Entry<'a> {
+        let pos = pos.into();
+        MemNodeEntry::new(pos, self.head())
+    }
+
+    fn locked(&self) -> Self::ArcLockedSegment {
+        ArcLockedSegmentView::new(self.inner.read_arc(), self.num_nodes())
+    }
+
+    fn flush(&self) -> Result<(), StorageError> {
+        Ok(())
+    }
+
+    fn vacuum(
+        &self,
+        _locked_head: impl DerefMut<Target = MemNodeSegment>,
+    ) -> Result<(), StorageError> {
+        Ok(())
+    }
+
+    fn immut_lsn(&self) -> LSN {
+        0
+    }
+
+    fn nodes_counter(&self) -> &AtomicU32 {
+        &self.max_num_node
+    }
+
+    fn num_layers(&self) -> usize {
+        self.head().layers.len()
+    }
+
+    fn layer_count(&self, layer_id: LayerId) -> u32 {
+        self.head()
+            .get_layer(layer_id)
+            .map_or(0, |layer| layer.len())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::{
+        LocalPOS, NodeSegmentView,
+        api::nodes::NodeSegmentOps,
+        pages::{layer_counter::GraphStats, node_page::writer::NodeWriter},
+        persist::{
+            config::BaseConfig,
+            strategy::{NoOpStrategy, PersistenceStrategy},
+        },
+    };
+    use raphtory_api::core::entities::properties::{
+        meta::{Meta, STATIC_GRAPH_LAYER_ID},
+        prop::{Prop, PropType},
+    };
+    use raphtory_core::entities::{EID, ELID, VID};
+    use std::sync::Arc;
+    use tempfile::tempdir;
+
+    #[test]
+    fn est_size_changes() {
+        let node_meta = Arc::new(Meta::default());
+        let edge_meta = Arc::new(Meta::default());
+        let path = tempdir().unwrap();
+        let config = BaseConfig::new(10, 10);
+        let ext = NoOpStrategy::new(config, None).unwrap();
+        let segment_id = 0;
+        let segment = NodeSegmentView::new(
+            segment_id,
+            node_meta.clone(),
+            edge_meta,
+            Some(path.path().to_path_buf()),
+            ext.clone(),
+        );
+        let stats = GraphStats::default();
+
+        let mut writer = NodeWriter::new(&segment, &stats, segment.head_mut());
+
+        let est_size1 = writer.mut_segment.est_size();
+        assert_eq!(est_size1, 0);
+
+        writer.add_outbound_edge(
+            Some(1),
+            LocalPOS(1),
+            VID(3),
+            EID(7).with_layer(STATIC_GRAPH_LAYER_ID),
+        );
+
+        let est_size2 = writer.mut_segment.est_size();
+        assert!(
+            est_size2 > est_size1,
+            "Estimated size should be greater than 0 after adding an edge"
+        );
+
+        writer.add_inbound_edge(
+            Some(1),
+            LocalPOS(2),
+            VID(4),
+            EID(8).with_layer(STATIC_GRAPH_LAYER_ID),
+        );
+
+        let est_size3 = writer.mut_segment.est_size();
+        assert!(
+            est_size3 > est_size2,
+            "Estimated size should increase after adding an inbound edge"
+        );
+
+        // no change when adding the same edge again
+
+        writer.add_outbound_edge::<i64>(
+            None,
+            LocalPOS(1),
+            VID(3),
+            EID(7).with_layer(STATIC_GRAPH_LAYER_ID),
+        );
+        let est_size4 = writer.mut_segment.est_size();
+        assert_eq!(
+            est_size4, est_size3,
+            "Estimated size should not change when adding the same edge again"
+        );
+
+        // add constant properties
+
+        let prop_id = node_meta
+            .metadata_mapper()
+            .get_or_create_and_validate("a", PropType::U64)
+            .unwrap()
+            .inner();
+
+        writer.update_c_props(
+            LocalPOS(1),
+            STATIC_GRAPH_LAYER_ID,
+            [(prop_id, Prop::U64(73))],
+        );
+
+        let est_size5 = writer.mut_segment.est_size();
+        assert!(
+            est_size5 > est_size4,
+            "Estimated size should increase after adding constant properties"
+        );
+
+        writer.update_timestamp(17, LocalPOS(1), ELID::new(EID(0), STATIC_GRAPH_LAYER_ID));
+
+        let est_size6 = writer.mut_segment.est_size();
+        assert!(
+            est_size6 > est_size5,
+            "Estimated size should increase after updating timestamp"
+        );
+
+        // add temporal properties
+        let prop_id = node_meta
+            .temporal_prop_mapper()
+            .get_or_create_and_validate("b", PropType::F64)
+            .unwrap()
+            .inner();
+
+        writer.add_props(
+            42,
+            LocalPOS(1),
+            STATIC_GRAPH_LAYER_ID,
+            [(prop_id, Prop::F64(4.13))],
+        );
+
+        let est_size7 = writer.mut_segment.est_size();
+        assert!(
+            est_size7 > est_size6,
+            "Estimated size should increase after adding temporal properties"
+        );
+
+        writer.add_props(
+            72,
+            LocalPOS(1),
+            STATIC_GRAPH_LAYER_ID,
+            [(prop_id, Prop::F64(5.41))],
+        );
+        let est_size8 = writer.mut_segment.est_size();
+        assert!(
+            est_size8 > est_size7,
+            "Estimated size should increase after adding another temporal property"
+        );
+        drop(writer);
+
+        // after drop the global estimated size should be the same as the last estimated size of the writer
+        assert_eq!(ext.estimated_size(), est_size8);
+
+        drop(segment);
+
+        // after the segment is dropped, the global estimated size should be zero (no more usage)
+        assert_eq!(ext.estimated_size(), 0);
+    }
+}
diff --git a/db4-storage/src/state.rs b/db4-storage/src/state.rs
new file mode 100644
index 0000000000..b12520b2d2
--- /dev/null
+++ b/db4-storage/src/state.rs
@@ -0,0 +1,892 @@
+use crate::pages::SegmentCounts;
+use rayon::prelude::*;
+use std::{
+    borrow::Borrow,
+    marker::PhantomData,
+    ops::{Index, IndexMut},
+    sync::Arc,
+};
+
+/// Index resolver for sharded storage with fixed-size chunks
+///
+/// Given a sharding scheme where items are distributed across chunks:
+/// - chunk_id = index / max_page_len
+/// - local_pos = index % max_page_len
+///
+/// This struct provides O(1) lookup to map any global index to a flat array position,
+/// accounting for partially filled chunks.
+///
+/// # Example
+/// With max_page_len = 1000:
+/// - Chunk 0: 1000 items (offsets[0] = 0, offsets[1] = 1000)
+/// - Chunk 1: 500 items  (offsets[1] = 1000, offsets[2] = 1500)
+/// - Chunk 2: 1000 items (offsets[2] = 1500, offsets[3] = 2500)
+///
+/// To resolve index 1200:
+/// - chunk = 1200 / 1000 = 1
+/// - local_pos = 1200 % 1000 = 200
+/// - flat_index = offsets[1] + 200 = 1000 + 200 = 1200
+#[derive(Debug, Clone)]
+pub struct StateIndex<I = usize> {
+    /// Cumulative offsets: offsets[chunk_id] = starting position in flat array for that chunk
+    /// Length is equal to number of chunks + 1 (includes final cumulative value)
+    offsets: Box<[usize]>,
+    /// Maximum items per chunk
+    max_page_len: u32,
+    /// Phantom data for index type
+    _marker: std::marker::PhantomData<I>,
+}
+
+impl<I> From<SegmentCounts<I>> for StateIndex<I>
+where
+    I: From<usize> + Into<usize>,
+{
+    fn from(counts: SegmentCounts<I>) -> Self {
+        Self::new(
+            counts.counts().iter().map(|c| *c as usize),
+            counts.max_seg_len(),
+        )
+    }
+}
+
+impl<I: From<usize> + Into<usize>> StateIndex<I> {
+    /// Create a new StateIndex with the given chunk configuration
+    ///
+    /// # Arguments
+    /// * `chunk_sizes` - The actual size of each chunk (can be <= max_page_len)
+    /// * `max_page_len` - Maximum capacity of each chunk
+    pub fn new(chunk_sizes: impl IntoIterator<Item = usize>, max_page_len: u32) -> Self {
+        // Build cumulative offsets (includes final cumulative value)
+        let mut offsets = Vec::new();
+        let mut cumulative = 0;
+        for size in chunk_sizes {
+            offsets.push(cumulative);
+            cumulative += size;
+        }
+        offsets.push(cumulative); // Add final cumulative value
+
+        Self {
+            offsets: offsets.into_boxed_slice(),
+            max_page_len,
+            _marker: std::marker::PhantomData,
+        }
+    }
+
+    /// Create a new StateIndex for mapping the union of both indexes
+    pub fn union(&self, other: &Self) -> Self {
+        let counts = self
+            .offsets
+            .iter()
+            .zip(other.offsets.iter())
+            .map(|(l, r)| *l.max(r));
+        let max_page_len = self.max_page_len.max(other.max_page_len);
+        Self::new(counts, max_page_len)
+    }
+
+    /// Resolve a global index to a flat array index
+    ///
+    /// # Arguments
+    /// * `index` - Global index across all chunks
+    ///
+    /// # Returns
+    /// Some(flat_index) if the index is valid, None otherwise
+    #[inline(always)]
+    pub fn resolve(&self, index: I) -> Option<usize> {
+        let index: usize = index.into();
+        let chunk = index / self.max_page_len as usize;
+        let local_pos = index % self.max_page_len as usize;
+
+        let offset = *self.offsets.get(chunk)?;
+        let flat_index = offset + local_pos;
+
+        // Verify the flat_index is within bounds of this chunk
+        let next_offset = *self.offsets.get(chunk + 1)?;
+        if flat_index < next_offset {
+            Some(flat_index)
+        } else {
+            None
+        }
+    }
+
+    pub fn global_index(&self, index: usize) -> Option<I> {
+        self.iter().nth(index)
+    }
+
+    /// Resolve a global index to a flat array index without bounds checking
+    ///
+    /// # Arguments
+    /// * `index` - Global index across all chunks
+    ///
+    /// # Returns
+    /// The flat array index
+    ///
+    /// # Safety
+    /// Panics if the index is out of bounds
+    #[inline(always)]
+    pub fn resolve_unchecked(&self, index: I) -> usize {
+        let index: usize = index.into();
+        let chunk = index / self.max_page_len as usize;
+        let local_pos = index % self.max_page_len as usize;
+
+        let offset = self.offsets[chunk];
+        offset + local_pos
+    }
+
+    /// Get the number of chunks
+    #[inline]
+    pub fn num_chunks(&self) -> usize {
+        self.offsets.len().saturating_sub(1)
+    }
+
+    /// Get the total number of items across all chunks
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.offsets[self.num_chunks()]
+    }
+
+    /// Check if there are no items
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Get the maximum page length
+    #[inline]
+    pub fn max_page_len(&self) -> u32 {
+        self.max_page_len
+    }
+
+    /// Create an iterator over all valid global indices
+    ///
+    /// This iterates through all chunks and yields the global indices for each item.
+    /// For example, with chunk_sizes [10, 1, 5] and max_page_len 10:
+    /// - Chunk 0: yields 0..10
+    /// - Chunk 1: yields 10..11
+    /// - Chunk 2: yields 20..25
+    pub fn iter(&self) -> StateIndexIter<&Self, I> {
+        StateIndexIter {
+            index: self,
+            current_chunk: 0,
+            current_local: 0,
+            _marker: PhantomData,
+        }
+    }
+
+    /// Create a parallel iterator over all valid global indices with their flat indices
+    ///
+    /// This iterates through all chunks in parallel and yields tuples of (flat_index, global_index).
+    /// The flat_index starts at 0 and increments for each item in iteration order.
+    ///
+    /// For example, with chunk_sizes [10, 1, 5] and max_page_len 10:
+    /// - Chunk 0: yields (0, 0)..(9, 9)
+    /// - Chunk 1: yields (10, 10)
+    /// - Chunk 2: yields (11, 20)..(15, 24)
+    pub fn par_iter(&self) -> impl ParallelIterator<Item = (usize, I)> + '_
+    where
+        I: Send + Sync,
+    {
+        let max_page_len = self.max_page_len as usize;
+        let num_chunks = self.num_chunks();
+        (0..num_chunks).into_par_iter().flat_map(move |chunk_idx| {
+            let chunk_start = self.offsets[chunk_idx];
+            let chunk_end = self.offsets[chunk_idx + 1];
+            let chunk_size = chunk_end - chunk_start;
+            let global_base = chunk_idx * max_page_len;
+            (0..chunk_size).into_par_iter().map(move |local_offset| {
+                let flat_idx = chunk_start + local_offset;
+                let global_idx = I::from(global_base + local_offset);
+                (flat_idx, global_idx)
+            })
+        })
+    }
+
+    pub fn arc_into_iter(self: Arc<Self>) -> StateIndexIter<Arc<Self>, I> {
+        StateIndexIter {
+            index: self,
+            current_chunk: 0,
+            current_local: 0,
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl<I: From<usize> + Into<usize>> StateIndex<I> {
+    /// Create a parallel iterator over all valid global indices with their flat indices
+    ///
+    /// This iterates through all chunks in parallel and yields tuples of (flat_index, global_index).
+    /// The flat_index starts at 0 and increments for each item in iteration order.
+    ///
+    /// For example, with chunk_sizes [10, 1, 5] and max_page_len 10:
+    /// - Chunk 0: yields (0, 0)..(9, 9)
+    /// - Chunk 1: yields (10, 10)
+    /// - Chunk 2: yields (11, 20)..(15, 24)
+    pub fn into_par_iter(self: Arc<Self>) -> impl ParallelIterator<Item = (usize, I)>
+    where
+        I: Send + Sync,
+    {
+        let max_page_len = self.max_page_len as usize;
+        let num_chunks = self.num_chunks();
+        (0..num_chunks).into_par_iter().flat_map(move |chunk_idx| {
+            let chunk_start = self.offsets[chunk_idx];
+            let chunk_end = self.offsets[chunk_idx + 1];
+            let chunk_size = chunk_end - chunk_start;
+            let global_base = chunk_idx * max_page_len;
+            (0..chunk_size).into_par_iter().map(move |local_offset| {
+                let flat_idx = chunk_start + local_offset;
+                let global_idx = I::from(global_base + local_offset);
+                (flat_idx, global_idx)
+            })
+        })
+    }
+}
+
+/// Iterator over global indices in a StateIndex
+#[derive(Debug, Clone)]
+pub struct StateIndexIter<I, V> {
+    index: I,
+    current_chunk: usize,
+    current_local: usize,
+    _marker: PhantomData<V>,
+}
+
+impl<V: From<usize> + Into<usize>, I: Borrow<StateIndex<V>>> Iterator for StateIndexIter<I, V> {
+    type Item = V;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let index = self.index.borrow();
+        loop {
+            if self.current_chunk >= index.num_chunks() {
+                return None;
+            }
+
+            let chunk_start = index.offsets[self.current_chunk];
+            let chunk_end = index.offsets[self.current_chunk + 1];
+            let chunk_size = chunk_end - chunk_start;
+
+            if self.current_local < chunk_size {
+                let global_idx =
+                    self.current_chunk * index.max_page_len as usize + self.current_local;
+                self.current_local += 1;
+                return Some(V::from(global_idx));
+            }
+
+            // Move to next chunk
+            self.current_chunk += 1;
+            self.current_local = 0;
+        }
+    }
+
+    fn nth(&mut self, n: usize) -> Option<Self::Item> {
+        let index = self.index.borrow();
+        // fast skip
+        if self.current_chunk >= index.num_chunks() {
+            return None;
+        }
+        let current = index.offsets[self.current_chunk] + self.current_local;
+        let target = current.saturating_add(n);
+        if &target >= index.offsets.last()? {
+            // need to set this so that future calls actually return None!
+            self.current_chunk = index.num_chunks();
+            return None;
+        }
+        // find the first offset > target, then substract 1 to get the last chunk starting at <= target
+        let skip_chunks = index.offsets[self.current_chunk..]
+            .partition_point(|&offset| offset <= target)
+            .saturating_sub(1);
+        self.current_chunk += skip_chunks;
+        self.current_local = target - index.offsets[self.current_chunk];
+        let global_idx = self.current_chunk * index.max_page_len as usize + self.current_local;
+        self.current_local += 1;
+        Some(V::from(global_idx))
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let index = self.index.borrow();
+        let total = index.len();
+        let consumed = if self.current_chunk < index.num_chunks() {
+            index.offsets[self.current_chunk] + self.current_local
+        } else {
+            total
+        };
+        let remaining = total.saturating_sub(consumed);
+        (remaining, Some(remaining))
+    }
+}
+
+impl<V: From<usize> + Into<usize>, I: Borrow<StateIndex<V>>> ExactSizeIterator
+    for StateIndexIter<I, V>
+{
+}
+
+impl<V: From<usize> + Into<usize>> IntoIterator for StateIndex<V> {
+    type Item = V;
+    type IntoIter = StateIndexIter<Self, V>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        StateIndexIter {
+            index: self,
+            current_chunk: 0,
+            current_local: 0,
+            _marker: PhantomData,
+        }
+    }
+}
+
+/// Address resolver for sharded storage with fixed-size chunks
+///
+/// This struct combines a StateIndex with a flat array to provide O(1) access
+/// to elements in a sharded storage scheme with partially filled chunks.
+#[derive(Debug)]
+pub struct State<A, I = usize> {
+    /// Index resolver
+    index: StateIndex<I>,
+    /// Flat array of state cells
+    state: Box<[A]>,
+}
+
+impl<A: Default, I: From<usize> + Into<usize>> State<A, I> {
+    /// Create a new State with the given chunk configuration
+    ///
+    /// # Arguments
+    /// * `chunk_sizes` - The actual size of each chunk (can be <= max_page_len)
+    /// * `max_page_len` - Maximum capacity of each chunk
+    ///
+    /// # Example
+    /// ```
+    /// use db4_storage::state::State;
+    /// use std::sync::atomic::AtomicUsize;
+    ///
+    /// // 3 chunks with sizes 1000, 500, 1000 and max capacity 1000
+    /// let state: State<AtomicUsize> = State::new(vec![1000, 500, 1000], 1000);
+    /// ```
+    pub fn new(chunk_sizes: Vec<usize>, max_page_len: u32) -> Self {
+        let index = StateIndex::<I>::new(chunk_sizes, max_page_len);
+        let total_size = index.len();
+
+        // Initialize state array with default values
+        let state: Box<[A]> = (0..total_size)
+            .map(|_| A::default())
+            .collect::<Vec<_>>()
+            .into_boxed_slice();
+
+        Self { index, state }
+    }
+
+    /// Get a reference to the StateIndex
+    #[inline]
+    pub fn index(&self) -> &StateIndex<I> {
+        &self.index
+    }
+
+    /// Get a reference to the cell for the given global index
+    ///
+    /// # Arguments
+    /// * `index` - Global index across all chunks
+    ///
+    /// # Returns
+    /// Some(&A) if the index is valid, None otherwise
+    #[inline(always)]
+    pub fn get(&self, index: I) -> Option<&A> {
+        let flat_index = self.index.resolve(index)?;
+        self.state.get(flat_index)
+    }
+
+    /// Get a mutable reference to the cell for the given global index
+    ///
+    /// # Arguments
+    /// * `index` - Global index across all chunks
+    ///
+    /// # Returns
+    /// Some(&mut A) if the index is valid, None otherwise
+    #[inline(always)]
+    pub fn get_mut(&mut self, index: I) -> Option<&mut A> {
+        let flat_index = self.index.resolve(index)?;
+        self.state.get_mut(flat_index)
+    }
+
+    /// Get a reference to the cell for the given global index without bounds checking
+    ///
+    /// # Arguments
+    /// * `index` - Global index across all chunks
+    ///
+    /// # Returns
+    /// Reference to the corresponding cell
+    ///
+    /// # Safety
+    /// Panics if the index is out of bounds
+    #[inline(always)]
+    pub fn get_unchecked(&self, index: I) -> &A {
+        let flat_index = self.index.resolve_unchecked(index);
+        &self.state[flat_index]
+    }
+
+    /// Get a mutable reference to the cell for the given global index without bounds checking
+    ///
+    /// # Arguments
+    /// * `index` - Global index across all chunks
+    ///
+    /// # Returns
+    /// Mutable reference to the corresponding cell
+    ///
+    /// # Safety
+    /// Panics if the index is out of bounds
+    #[inline(always)]
+    pub fn get_mut_unchecked(&mut self, index: I) -> &mut A {
+        let flat_index = self.index.resolve_unchecked(index);
+        &mut self.state[flat_index]
+    }
+
+    /// Get the number of chunks
+    #[inline]
+    pub fn num_chunks(&self) -> usize {
+        self.index.num_chunks()
+    }
+
+    /// Get the total number of state cells
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.state.len()
+    }
+
+    /// Check if the state is empty
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.state.is_empty()
+    }
+
+    /// Get the maximum page length
+    #[inline]
+    pub fn max_page_len(&self) -> u32 {
+        self.index.max_page_len()
+    }
+
+    /// Create an iterator over all elements in the state
+    ///
+    /// Yields references to each element in order of their global indices.
+    pub fn iter(&self) -> StateIter<'_, A, I> {
+        StateIter {
+            state: self,
+            inner: self.index.iter(),
+        }
+    }
+}
+
+/// Iterator over elements in a State
+#[derive(Debug)]
+pub struct StateIter<'a, A, I> {
+    state: &'a State<A, I>,
+    inner: StateIndexIter<&'a StateIndex<I>, I>,
+}
+
+impl<'a, A: Default, I: From<usize> + Into<usize>> Iterator for StateIter<'a, A, I> {
+    type Item = &'a A;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let global_idx = self.inner.next()?;
+        Some(self.state.get_unchecked(global_idx))
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.inner.size_hint()
+    }
+}
+
+impl<'a, A: Default, I: From<usize> + Into<usize>> ExactSizeIterator for StateIter<'a, A, I> {
+    fn len(&self) -> usize {
+        self.inner.len()
+    }
+}
+
+impl<A: Default, I: From<usize> + Into<usize> + std::fmt::Debug + Copy> Index<I> for State<A, I> {
+    type Output = A;
+
+    #[inline(always)]
+    fn index(&self, index: I) -> &Self::Output {
+        self.get(index)
+            .unwrap_or_else(|| panic!("index out of bounds: {:?}", index))
+    }
+}
+
+impl<A: Default, I: From<usize> + Into<usize> + std::fmt::Debug + Copy> IndexMut<I>
+    for State<A, I>
+{
+    #[inline(always)]
+    fn index_mut(&mut self, index: I) -> &mut Self::Output {
+        self.get_mut(index)
+            .unwrap_or_else(|| panic!("index out of bounds: {:?}", index))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::atomic::{AtomicUsize, Ordering};
+
+    #[test]
+    fn test_state_index_resolve() {
+        let index: StateIndex<usize> = StateIndex::new(vec![1000, 500, 1000], 1000);
+
+        assert_eq!(index.num_chunks(), 3);
+        assert_eq!(index.len(), 2500);
+        assert_eq!(index.max_page_len(), 1000);
+
+        // Test chunk 0
+        assert_eq!(index.resolve(0), Some(0));
+        assert_eq!(index.resolve(999), Some(999));
+
+        // Test chunk 1
+        assert_eq!(index.resolve(1000), Some(1000));
+        assert_eq!(index.resolve(1499), Some(1499));
+
+        // Test chunk 2
+        assert_eq!(index.resolve(2000), Some(1500));
+        assert_eq!(index.resolve(2999), Some(2499));
+
+        // Test out of bounds
+        assert_eq!(index.resolve(3000), None);
+        assert_eq!(index.resolve(1500), None); // In chunk 1 but beyond its actual size
+    }
+
+    #[test]
+    fn test_basic_get() {
+        let state: State<AtomicUsize> = State::new(vec![1000, 500, 1000], 1000);
+
+        // Test chunk 0
+        state.get_unchecked(0).store(42, Ordering::Relaxed);
+        assert_eq!(state.get_unchecked(0).load(Ordering::Relaxed), 42);
+
+        state.get_unchecked(999).store(123, Ordering::Relaxed);
+        assert_eq!(state.get_unchecked(999).load(Ordering::Relaxed), 123);
+
+        // Test chunk 1 (offset should be 1000)
+        state.get_unchecked(1000).store(77, Ordering::Relaxed);
+        assert_eq!(state.get_unchecked(1000).load(Ordering::Relaxed), 77);
+
+        state.get_unchecked(1499).store(88, Ordering::Relaxed);
+        assert_eq!(state.get_unchecked(1499).load(Ordering::Relaxed), 88);
+
+        // Test chunk 2 (offset should be 1500)
+        state.get_unchecked(2000).store(99, Ordering::Relaxed);
+        assert_eq!(state.get_unchecked(2000).load(Ordering::Relaxed), 99);
+
+        state.get_unchecked(2999).store(111, Ordering::Relaxed);
+        assert_eq!(state.get_unchecked(2999).load(Ordering::Relaxed), 111);
+    }
+
+    #[test]
+    fn test_get_option() {
+        let state: State<AtomicUsize> = State::new(vec![100, 50], 100);
+
+        assert!(state.get(0).is_some());
+        assert!(state.get(99).is_some());
+        assert!(state.get(100).is_some());
+        assert!(state.get(149).is_some());
+
+        // Out of bounds chunk
+        assert!(state.get(200).is_none());
+        assert!(state.get(1000).is_none());
+
+        // In bounds chunk but beyond chunk's actual size
+        assert!(state.get(150).is_none());
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_out_of_bounds_chunk() {
+        let state: State<AtomicUsize> = State::new(vec![100], 100);
+        state.get_unchecked(200); // Should panic
+    }
+
+    #[test]
+    fn test_partially_filled_chunks() {
+        // Simulate real scenario: chunks with varying fill levels
+        let state: State<AtomicUsize> = State::new(vec![1000, 300, 1000, 50], 1000);
+
+        // First chunk - fully filled
+        state.get_unchecked(0).store(1, Ordering::Relaxed);
+        state.get_unchecked(999).store(2, Ordering::Relaxed);
+        assert_eq!(state.get_unchecked(0).load(Ordering::Relaxed), 1);
+        assert_eq!(state.get_unchecked(999).load(Ordering::Relaxed), 2);
+
+        // Second chunk - partially filled (300 items)
+        // Global indices: 1000-1299
+        state.get_unchecked(1000).store(3, Ordering::Relaxed);
+        state.get_unchecked(1299).store(4, Ordering::Relaxed);
+        assert_eq!(state.get_unchecked(1000).load(Ordering::Relaxed), 3);
+        assert_eq!(state.get_unchecked(1299).load(Ordering::Relaxed), 4);
+
+        // Third chunk - fully filled
+        // Global indices: 2000-2999
+        state.get_unchecked(2000).store(5, Ordering::Relaxed);
+        state.get_unchecked(2999).store(6, Ordering::Relaxed);
+        assert_eq!(state.get_unchecked(2000).load(Ordering::Relaxed), 5);
+        assert_eq!(state.get_unchecked(2999).load(Ordering::Relaxed), 6);
+
+        // Fourth chunk - minimally filled (50 items)
+        // Global indices: 3000-3049
+        state.get_unchecked(3000).store(7, Ordering::Relaxed);
+        state.get_unchecked(3049).store(8, Ordering::Relaxed);
+        assert_eq!(state.get_unchecked(3000).load(Ordering::Relaxed), 7);
+        assert_eq!(state.get_unchecked(3049).load(Ordering::Relaxed), 8);
+
+        assert_eq!(state.len(), 2350); // 1000 + 300 + 1000 + 50
+        assert_eq!(state.num_chunks(), 4);
+    }
+
+    #[test]
+    fn test_resolve_pos_consistency() {
+        // Test that our addressing matches the resolve_pos function
+        let max_page_len = 1000u32;
+        let state: State<AtomicUsize> = State::new(vec![1000, 500, 1000], max_page_len);
+
+        // Helper to simulate resolve_pos
+        let resolve_pos = |i: usize| -> (usize, u32) {
+            let chunk = i / max_page_len as usize;
+            let pos = (i % max_page_len as usize) as u32;
+            (chunk, pos)
+        };
+
+        for index in [0, 500, 999, 1000, 1250, 1499, 2000, 2500, 2999] {
+            let (chunk, local_pos) = resolve_pos(index);
+
+            // Verify our addressing scheme matches
+            let computed_chunk = index / max_page_len as usize;
+            let computed_local = index % max_page_len as usize;
+
+            assert_eq!(chunk, computed_chunk);
+            assert_eq!(local_pos, computed_local as u32);
+
+            // Verify we can access the cell
+            state.get_unchecked(index).store(index, Ordering::Relaxed);
+            assert_eq!(state.get_unchecked(index).load(Ordering::Relaxed), index);
+        }
+    }
+
+    #[test]
+    fn test_generic_over_different_types() {
+        // Test with usize
+        let state_usize: State<usize> = State::new(vec![10, 5], 10);
+        assert_eq!(*state_usize.get_unchecked(0), 0);
+        assert_eq!(*state_usize.get_unchecked(10), 0);
+
+        // Test with Option
+        let state_option: State<Option<i32>> = State::new(vec![10, 5], 10);
+        assert_eq!(*state_option.get_unchecked(0), None);
+        assert_eq!(*state_option.get_unchecked(10), None);
+
+        // Test with AtomicUsize
+        let state_atomic: State<AtomicUsize> = State::new(vec![10, 5], 10);
+        state_atomic.get_unchecked(0).store(42, Ordering::Relaxed);
+        assert_eq!(state_atomic.get_unchecked(0).load(Ordering::Relaxed), 42);
+    }
+
+    #[test]
+    fn test_mutable_access() {
+        let mut state: State<usize> = State::new(vec![100, 50], 100);
+
+        // Test get_mut
+        *state.get_mut(0).unwrap() = 42;
+        assert_eq!(*state.get(0).unwrap(), 42);
+
+        *state.get_mut(50).unwrap() = 99;
+        assert_eq!(*state.get(50).unwrap(), 99);
+
+        // Test get_mut in second chunk
+        *state.get_mut(100).unwrap() = 123;
+        assert_eq!(*state.get(100).unwrap(), 123);
+
+        // Test get_mut_unchecked
+        *state.get_mut_unchecked(10) = 77;
+        assert_eq!(*state.get_unchecked(10), 77);
+
+        // Test out of bounds returns None
+        assert!(state.get_mut(200).is_none());
+    }
+
+    #[test]
+    fn test_index_trait() {
+        let mut state: State<usize> = State::new(vec![100, 50], 100);
+
+        // Test Index trait
+        state[0] = 42;
+        assert_eq!(state[0], 42);
+
+        state[99] = 100;
+        assert_eq!(state[99], 100);
+
+        // Test in second chunk
+        state[100] = 200;
+        assert_eq!(state[100], 200);
+
+        state[149] = 300;
+        assert_eq!(state[149], 300);
+    }
+
+    #[test]
+    #[should_panic(expected = "index out of bounds")]
+    fn test_index_out_of_bounds() {
+        let state: State<usize> = State::new(vec![100], 100);
+        let _ = state[200];
+    }
+
+    #[test]
+    fn test_offsets_include_final_cumulative() {
+        let state: State<usize> = State::new(vec![1000, 500, 1000], 1000);
+
+        // offsets should be [0, 1000, 1500, 2500]
+        assert_eq!(state.num_chunks(), 3);
+        assert_eq!(state.len(), 2500);
+
+        // Verify via StateIndex API
+        assert_eq!(state.index().len(), state.len());
+    }
+
+    #[test]
+    fn test_state_index_can_be_used_independently() {
+        // StateIndex can be used independently of State
+        let index: StateIndex<usize> = StateIndex::new(vec![1000, 500, 1000], 1000);
+
+        // Create your own array
+        let mut data = vec![0usize; index.len()];
+
+        // Use the index to access elements
+        if let Some(flat_idx) = index.resolve(1200) {
+            data[flat_idx] = 42;
+        }
+
+        if let Some(flat_idx) = index.resolve(1200) {
+            assert_eq!(data[flat_idx], 42);
+        }
+    }
+
+    #[test]
+    fn test_state_index_iter() {
+        let index: StateIndex<usize> = StateIndex::new(vec![10, 1, 5], 10);
+
+        let global_indices: Vec<usize> = index.iter().collect();
+
+        // Chunk 0: global indices 0-9 (10 items)
+        // Chunk 1: global index 10 (1 item)
+        // Chunk 2: global indices 20-24 (5 items)
+        let expected = vec![
+            0, 1, 2, 3, 4, 5, 6, 7, 8, 9,  // Chunk 0
+            10, // Chunk 1
+            20, 21, 22, 23, 24, // Chunk 2
+        ];
+
+        assert_eq!(global_indices, expected);
+        assert_eq!(index.iter().len(), 16);
+    }
+
+    #[test]
+    fn test_state_index_par_iter() {
+        let index: StateIndex<usize> = StateIndex::new(vec![10, 1, 5], 10);
+
+        let mut results: Vec<(usize, usize)> = index.par_iter().collect();
+        results.sort_by_key(|(flat_idx, _)| *flat_idx); // Sort by flat index
+
+        // Expected: (flat_idx, global_idx) tuples
+        // Chunk 0: flat indices 0-9, global indices 0-9
+        // Chunk 1: flat index 10, global index 10
+        // Chunk 2: flat indices 11-15, global indices 20-24
+        let expected = vec![
+            (0, 0),
+            (1, 1),
+            (2, 2),
+            (3, 3),
+            (4, 4),
+            (5, 5),
+            (6, 6),
+            (7, 7),
+            (8, 8),
+            (9, 9),   // Chunk 0
+            (10, 10), // Chunk 1
+            (11, 20),
+            (12, 21),
+            (13, 22),
+            (14, 23),
+            (15, 24), // Chunk 2
+        ];
+
+        assert_eq!(results, expected);
+
+        // Verify count matches
+        assert_eq!(index.par_iter().count(), 16);
+
+        // Verify flat indices are sequential
+        let flat_indices: Vec<usize> = results.iter().map(|(flat_idx, _)| *flat_idx).collect();
+        assert_eq!(flat_indices, (0..16).collect::<Vec<_>>());
+    }
+
+    #[test]
+    fn test_state_iter() {
+        let mut state: State<usize> = State::new(vec![10, 1, 5], 10);
+
+        // Collect global indices first to avoid borrow checker issues
+        let global_indices: Vec<usize> = state.index().iter().collect();
+
+        // Initialize state with global indices
+        for global_idx in global_indices {
+            state[global_idx] = global_idx * 10;
+        }
+
+        // Collect values via iter
+        let values: Vec<usize> = state.iter().copied().collect();
+
+        let expected = vec![
+            0, 10, 20, 30, 40, 50, 60, 70, 80, 90,  // Chunk 0
+            100, // Chunk 1
+            200, 210, 220, 230, 240, // Chunk 2
+        ];
+
+        assert_eq!(values, expected);
+        assert_eq!(state.iter().len(), 16);
+    }
+
+    #[test]
+    fn test_state_iter_with_atomics() {
+        let state: State<AtomicUsize> = State::new(vec![10, 5], 10);
+
+        // Collect global indices first to avoid borrow checker issues
+        let global_indices: Vec<usize> = state.index().iter().collect();
+
+        // Set values via global indices
+        for global_idx in global_indices {
+            state
+                .get_unchecked(global_idx)
+                .store(global_idx, Ordering::Relaxed);
+        }
+
+        // Read via iterator
+        let values: Vec<usize> = state.iter().map(|a| a.load(Ordering::Relaxed)).collect();
+
+        let expected = vec![
+            0, 1, 2, 3, 4, 5, 6, 7, 8, 9, // Chunk 0
+            10, 11, 12, 13, 14, // Chunk 1
+        ];
+
+        assert_eq!(values, expected);
+    }
+
+    #[test]
+    fn test_iter_skip() {
+        let index: StateIndex<usize> = StateIndex::new(vec![10, 1, 5], 10);
+
+        let expected: Vec<_> = (0..10).chain(10..11).chain(20..25).collect();
+        // check all skips
+        for (i, v) in expected.iter().copied().enumerate() {
+            assert_eq!(index.iter().nth(i), Some(v));
+        }
+
+        assert_eq!(index.iter().nth(100), None);
+
+        // check that iterator is correctly exhausted after calling nth
+        let mut iter = index.iter();
+        assert_eq!(iter.nth(16), None);
+        assert!(iter.next().is_none());
+
+        let mut iter = index.iter();
+        assert_eq!(iter.nth(15), Some(expected[15]));
+        assert!(iter.next().is_none());
+    }
+}
diff --git a/db4-storage/src/transaction/mod.rs b/db4-storage/src/transaction/mod.rs
new file mode 100644
index 0000000000..439e5b00de
--- /dev/null
+++ b/db4-storage/src/transaction/mod.rs
@@ -0,0 +1,40 @@
+use std::sync::atomic::{self, AtomicU64};
+
+use crate::wal::TransactionID;
+
+#[derive(Debug)]
+pub struct TransactionManager {
+    last_transaction_id: AtomicU64,
+}
+
+impl TransactionManager {
+    const STARTING_TRANSACTION_ID: TransactionID = 1;
+
+    pub fn new() -> Self {
+        Self {
+            last_transaction_id: AtomicU64::new(Self::STARTING_TRANSACTION_ID),
+        }
+    }
+
+    /// Restores the last used transaction ID to the specified value.
+    /// Intended for using during recovery.
+    pub fn restore_transaction_id(&self, last_transaction_id: TransactionID) {
+        self.last_transaction_id
+            .store(last_transaction_id, atomic::Ordering::SeqCst)
+    }
+
+    pub fn begin_transaction(&self) -> TransactionID {
+        self.last_transaction_id
+            .fetch_add(1, atomic::Ordering::SeqCst)
+    }
+
+    pub fn end_transaction(&self, _transaction_id: TransactionID) {
+        // No-op for now.
+    }
+}
+
+impl Default for TransactionManager {
+    fn default() -> Self {
+        Self::new()
+    }
+}
diff --git a/db4-storage/src/utils.rs b/db4-storage/src/utils.rs
new file mode 100644
index 0000000000..9a28e2d86e
--- /dev/null
+++ b/db4-storage/src/utils.rs
@@ -0,0 +1,52 @@
+use iter_enum::{
+    DoubleEndedIterator, ExactSizeIterator, FusedIterator, IndexedParallelIterator, Iterator,
+    ParallelIterator,
+};
+
+#[derive(
+    Clone,
+    Debug,
+    Iterator,
+    DoubleEndedIterator,
+    ExactSizeIterator,
+    ParallelIterator,
+    IndexedParallelIterator,
+    FusedIterator,
+)]
+pub enum Iter2<I1, I2> {
+    I1(I1),
+    I2(I2),
+}
+
+#[derive(
+    Copy,
+    Clone,
+    Iterator,
+    ExactSizeIterator,
+    DoubleEndedIterator,
+    ParallelIterator,
+    IndexedParallelIterator,
+    FusedIterator,
+)]
+pub enum Iter3<I, J, K> {
+    I(I),
+    J(J),
+    K(K),
+}
+
+#[derive(
+    Copy,
+    Clone,
+    Iterator,
+    ExactSizeIterator,
+    DoubleEndedIterator,
+    ParallelIterator,
+    IndexedParallelIterator,
+    FusedIterator,
+)]
+pub enum Iter4<I, J, K, L> {
+    I(I),
+    J(J),
+    K(K),
+    L(L),
+}
diff --git a/db4-storage/src/wal/entry.rs b/db4-storage/src/wal/entry.rs
new file mode 100644
index 0000000000..002723af7d
--- /dev/null
+++ b/db4-storage/src/wal/entry.rs
@@ -0,0 +1,133 @@
+use raphtory_api::core::entities::{GidRef, LayerId, properties::prop::Prop};
+use raphtory_core::{
+    entities::{EID, VID},
+    storage::timeindex::EventTime,
+};
+
+use crate::{
+    error::StorageError,
+    wal::{GraphReplay, GraphWalOps, LSN, TransactionID, no_wal::NoWal},
+};
+
+impl GraphWalOps for NoWal {
+    type ReplayEntry = ();
+
+    fn log_add_edge(
+        &self,
+        _transaction_id: TransactionID,
+        _t: EventTime,
+        _src_name: Option<GidRef<'_>>,
+        _src_id: VID,
+        _dst_name: Option<GidRef<'_>>,
+        _dst_id: VID,
+        _eid: EID,
+        _layer_name: Option<&str>,
+        _layer_id: LayerId,
+        _props: Vec<(&str, usize, Prop)>,
+    ) -> Result<LSN, StorageError> {
+        Ok(0)
+    }
+
+    fn log_add_edge_metadata(
+        &self,
+        _transaction_id: TransactionID,
+        _eid: EID,
+        _layer_id: LayerId,
+        _props: Vec<(&str, usize, Prop)>,
+    ) -> Result<LSN, StorageError> {
+        Ok(0)
+    }
+
+    fn log_delete_edge(
+        &self,
+        _transaction_id: TransactionID,
+        _t: EventTime,
+        _src_name: Option<GidRef<'_>>,
+        _src_id: VID,
+        _dst_name: Option<GidRef<'_>>,
+        _dst_id: VID,
+        _eid: EID,
+        _layer_name: Option<&str>,
+        _layer_id: LayerId,
+    ) -> Result<LSN, StorageError> {
+        Ok(0)
+    }
+
+    fn log_add_node(
+        &self,
+        _transaction_id: TransactionID,
+        _t: EventTime,
+        _node_name: Option<GidRef<'_>>,
+        _node_id: VID,
+        _node_type_and_id: Option<(&str, usize)>,
+        _props: Vec<(&str, usize, Prop)>,
+        _layer_name: Option<&str>,
+        _layer_id: LayerId,
+    ) -> Result<LSN, StorageError> {
+        Ok(0)
+    }
+
+    fn log_add_node_metadata(
+        &self,
+        _transaction_id: TransactionID,
+        _vid: VID,
+        _props: Vec<(&str, usize, Prop)>,
+    ) -> Result<LSN, StorageError> {
+        Ok(0)
+    }
+
+    fn log_set_node_type(
+        &self,
+        _transaction_id: TransactionID,
+        _vid: VID,
+        _node_type: &str,
+        _node_type_id: usize,
+    ) -> Result<LSN, StorageError> {
+        Ok(0)
+    }
+
+    fn log_add_graph_props(
+        &self,
+        _transaction_id: TransactionID,
+        _t: EventTime,
+        _props: Vec<(&str, usize, Prop)>,
+    ) -> Result<LSN, StorageError> {
+        Ok(0)
+    }
+
+    fn log_add_graph_metadata(
+        &self,
+        _transaction_id: TransactionID,
+        _props: Vec<(&str, usize, Prop)>,
+    ) -> Result<LSN, StorageError> {
+        Ok(0)
+    }
+
+    fn log_checkpoint(&self, _redo: LSN) -> Result<LSN, StorageError> {
+        Ok(0)
+    }
+
+    fn log_shutdown_checkpoint(&self) -> Result<LSN, StorageError> {
+        Ok(0)
+    }
+
+    fn read_checkpoint(&self, _lsn: LSN) -> Result<LSN, StorageError> {
+        Err(StorageError::GenericFailure(
+            "read_checkpoint is not supported for NoWAL".to_string(),
+        ))
+    }
+
+    fn read_shutdown_checkpoint(&self, _lsn: LSN) -> Result<LSN, StorageError> {
+        Err(StorageError::GenericFailure(
+            "read_shutdown_checkpoint is not supported for NoWAL".to_string(),
+        ))
+    }
+
+    fn replay_to_graph<G: GraphReplay>(
+        &self,
+        _graph: &mut G,
+        _start: LSN,
+    ) -> Result<LSN, StorageError> {
+        panic!("NoWAL does not support replay")
+    }
+}
diff --git a/db4-storage/src/wal/mod.rs b/db4-storage/src/wal/mod.rs
new file mode 100644
index 0000000000..e933504121
--- /dev/null
+++ b/db4-storage/src/wal/mod.rs
@@ -0,0 +1,256 @@
+use crate::error::StorageError;
+use raphtory_api::core::entities::{GidRef, LayerId, properties::prop::Prop};
+use raphtory_core::{
+    entities::{EID, GID, VID},
+    storage::timeindex::EventTime,
+};
+
+pub mod entry;
+pub mod no_wal;
+
+pub type LSN = u64;
+pub type TransactionID = u64;
+
+/// Core Wal methods.
+pub trait WalOps {
+    /// Appends data to the WAL and returns the assigned LSN.
+    fn append(&self, data: &[u8]) -> Result<LSN, StorageError>;
+
+    /// Flushes in-memory WAL entries up to the given LSN to disk.
+    /// Returns immediately if the given LSN is already flushed to disk.
+    fn flush(&self, lsn: LSN) -> Result<(), StorageError>;
+
+    /// Reads the WAL record at the given LSN.
+    /// Returns `Ok(None)` if there is no record at that LSN.
+    fn read(&self, lsn: LSN) -> Result<Option<ReplayRecord>, StorageError>;
+
+    /// Returns an iterator over the entries in the wal, starting from the given LSN.
+    fn replay(&self, start: LSN) -> impl Iterator<Item = Result<ReplayRecord, StorageError>>;
+
+    /// Returns the current position in the WAL stream.
+    fn position(&self) -> LSN;
+
+    /// Sets the position in the WAL stream.
+    fn set_position(&self, lsn: LSN) -> Result<(), StorageError>;
+}
+
+#[derive(Debug)]
+pub struct ReplayRecord {
+    lsn: LSN,
+
+    data: Vec<u8>,
+
+    /// LSN immediately after this record in the WAL stream.
+    next_lsn: LSN,
+}
+
+impl ReplayRecord {
+    pub fn new(lsn: LSN, data: Vec<u8>, next_lsn: LSN) -> Self {
+        Self {
+            lsn,
+            data,
+            next_lsn,
+        }
+    }
+
+    pub fn lsn(&self) -> LSN {
+        self.lsn
+    }
+
+    /// Returns the LSN immediately following this record in the WAL stream.
+    pub fn next_lsn(&self) -> LSN {
+        self.next_lsn
+    }
+
+    pub fn data(&self) -> &[u8] {
+        &self.data
+    }
+}
+
+// Raphtory-specific logging & replay methods.
+pub trait GraphWalOps {
+    /// ReplayEntry represents the type of the wal entry returned during replay.
+    type ReplayEntry;
+
+    fn log_add_edge(
+        &self,
+        transaction_id: TransactionID,
+        t: EventTime,
+        src_name: Option<GidRef<'_>>,
+        src_id: VID,
+        dst_name: Option<GidRef<'_>>,
+        dst_id: VID,
+        eid: EID,
+        layer_name: Option<&str>,
+        layer_id: LayerId,
+        props: Vec<(&str, usize, Prop)>,
+    ) -> Result<LSN, StorageError>;
+
+    fn log_add_edge_metadata(
+        &self,
+        transaction_id: TransactionID,
+        eid: EID,
+        layer_id: LayerId,
+        props: Vec<(&str, usize, Prop)>,
+    ) -> Result<LSN, StorageError>;
+
+    fn log_delete_edge(
+        &self,
+        transaction_id: TransactionID,
+        t: EventTime,
+        src_name: Option<GidRef<'_>>,
+        src_id: VID,
+        dst_name: Option<GidRef<'_>>,
+        dst_id: VID,
+        eid: EID,
+        layer_name: Option<&str>,
+        layer_id: LayerId,
+    ) -> Result<LSN, StorageError>;
+
+    fn log_add_node(
+        &self,
+        transaction_id: TransactionID,
+        t: EventTime,
+        node_name: Option<GidRef<'_>>,
+        node_id: VID,
+        node_type_and_id: Option<(&str, usize)>,
+        props: Vec<(&str, usize, Prop)>,
+        layer_name: Option<&str>,
+        layer_id: LayerId,
+    ) -> Result<LSN, StorageError>;
+
+    fn log_add_node_metadata(
+        &self,
+        transaction_id: TransactionID,
+        vid: VID,
+        props: Vec<(&str, usize, Prop)>,
+    ) -> Result<LSN, StorageError>;
+
+    fn log_set_node_type(
+        &self,
+        transaction_id: TransactionID,
+        vid: VID,
+        node_type: &str,
+        node_type_id: usize,
+    ) -> Result<LSN, StorageError>;
+
+    fn log_add_graph_props(
+        &self,
+        transaction_id: TransactionID,
+        t: EventTime,
+        props: Vec<(&str, usize, Prop)>,
+    ) -> Result<LSN, StorageError>;
+
+    fn log_add_graph_metadata(
+        &self,
+        transaction_id: TransactionID,
+        props: Vec<(&str, usize, Prop)>,
+    ) -> Result<LSN, StorageError>;
+
+    /// Logs a checkpoint indicating that all LSN < `redo` are persisted.
+    /// On recovery, replay will start from `redo` in the WAL stream.
+    fn log_checkpoint(&self, redo: LSN) -> Result<LSN, StorageError>;
+
+    /// Logs a shutdown checkpoint indicating a clean shutdown with all writes persisted.
+    fn log_shutdown_checkpoint(&self) -> Result<LSN, StorageError>;
+
+    /// Reads and decodes the WAL entry at the given LSN and validates that it is a checkpoint.
+    /// Returns the checkpoint redo LSN, denoting where replay should start from.
+    fn read_checkpoint(&self, lsn: LSN) -> Result<LSN, StorageError>;
+
+    /// Reads and decodes the WAL entry at the given LSN and validates that it is a shutdown checkpoint.
+    /// Returns the LSN immediately after this record, marking the end of the WAL stream.
+    fn read_shutdown_checkpoint(&self, lsn: LSN) -> Result<LSN, StorageError>;
+
+    /// Replays and applies all the entries in the wal to the given graph, starting from the given LSN.
+    /// Returns the LSN immediately after the last entry in the WAL stream on success.
+    fn replay_to_graph<G: GraphReplay>(
+        &self,
+        graph: &mut G,
+        start: LSN,
+    ) -> Result<LSN, StorageError>;
+}
+
+/// Trait for defining callbacks for replaying from wal.
+pub trait GraphReplay {
+    fn replay_add_edge(
+        &mut self,
+        lsn: LSN,
+        transaction_id: TransactionID,
+        t: EventTime,
+        src_name: Option<GID>,
+        src_id: VID,
+        dst_name: Option<GID>,
+        dst_id: VID,
+        eid: EID,
+        layer_name: Option<String>,
+        layer_id: LayerId,
+        props: Vec<(String, usize, Prop)>,
+    ) -> Result<(), StorageError>;
+
+    fn replay_add_edge_metadata(
+        &mut self,
+        lsn: LSN,
+        transaction_id: TransactionID,
+        eid: EID,
+        layer_id: LayerId,
+        props: Vec<(String, usize, Prop)>,
+    ) -> Result<(), StorageError>;
+
+    fn replay_delete_edge(
+        &mut self,
+        lsn: LSN,
+        transaction_id: TransactionID,
+        t: EventTime,
+        src_name: Option<GID>,
+        src_id: VID,
+        dst_name: Option<GID>,
+        dst_id: VID,
+        eid: EID,
+        layer_name: Option<String>,
+        layer_id: LayerId,
+    ) -> Result<(), StorageError>;
+
+    fn replay_add_node(
+        &mut self,
+        lsn: LSN,
+        transaction_id: TransactionID,
+        t: EventTime,
+        node_name: Option<GID>,
+        node_id: VID,
+        node_type_and_id: Option<(String, usize)>,
+        props: Vec<(String, usize, Prop)>,
+    ) -> Result<(), StorageError>;
+
+    fn replay_add_node_metadata(
+        &mut self,
+        lsn: LSN,
+        transaction_id: TransactionID,
+        vid: VID,
+        props: Vec<(String, usize, Prop)>,
+    ) -> Result<(), StorageError>;
+
+    fn replay_set_node_type(
+        &mut self,
+        lsn: LSN,
+        transaction_id: TransactionID,
+        vid: VID,
+        node_type: String,
+        node_type_id: usize,
+    ) -> Result<(), StorageError>;
+
+    fn replay_add_graph_props(
+        &mut self,
+        lsn: LSN,
+        transaction_id: TransactionID,
+        t: EventTime,
+        props: Vec<(String, usize, Prop)>,
+    ) -> Result<(), StorageError>;
+
+    fn replay_add_graph_metadata(
+        &mut self,
+        lsn: LSN,
+        transaction_id: TransactionID,
+        props: Vec<(String, usize, Prop)>,
+    ) -> Result<(), StorageError>;
+}
diff --git a/db4-storage/src/wal/no_wal.rs b/db4-storage/src/wal/no_wal.rs
new file mode 100644
index 0000000000..7f563080ca
--- /dev/null
+++ b/db4-storage/src/wal/no_wal.rs
@@ -0,0 +1,40 @@
+use crate::{
+    error::StorageError,
+    wal::{LSN, ReplayRecord, WalOps},
+};
+
+/// `NoWAL` is a no-op WAL implementation that discards all writes.
+/// Used for in-memory only graphs.
+#[derive(Debug, Copy, Clone)]
+pub struct NoWal;
+
+impl WalOps for NoWal {
+    fn append(&self, _data: &[u8]) -> Result<LSN, StorageError> {
+        Ok(0)
+    }
+
+    fn flush(&self, _lsn: LSN) -> Result<(), StorageError> {
+        Ok(())
+    }
+
+    fn replay(&self, _start: LSN) -> impl Iterator<Item = Result<ReplayRecord, StorageError>> {
+        let error = "Recovery is not supported for NoWAL";
+        std::iter::once(Err(StorageError::GenericFailure(error.to_string())))
+    }
+
+    fn read(&self, _lsn: LSN) -> Result<Option<ReplayRecord>, StorageError> {
+        Err(StorageError::GenericFailure(
+            "read is not supported for NoWAL".to_string(),
+        ))
+    }
+
+    fn position(&self) -> LSN {
+        0
+    }
+
+    fn set_position(&self, _lsn: LSN) -> Result<(), StorageError> {
+        Err(StorageError::GenericFailure(
+            "set_position is not supported for NoWAL".to_string(),
+        ))
+    }
+}
diff --git a/docs/reference/graphql/graphql_API.md b/docs/reference/graphql/graphql_API.md
index c7d231b158..50823287f0 100644
--- a/docs/reference/graphql/graphql_API.md
+++ b/docs/reference/graphql/graphql_API.md
@@ -9,6 +9,12 @@ hide:
 
 
 ## Query (QueryRoot)
+Top-level READ-only query root. Entry points for loading a graph
+(`graph`, `graphMetadata`), browsing stored graphs (`namespaces`,
+`namespace`, `root`), downloading a stored graph as a base64 blob
+(`receiveGraph`), inspecting vectorised variants (`vectorisedGraph`),
+and a few utility endpoints (`version`, `hello`, `plugins`).
+
 <table>
 <thead>
 <tr>
@@ -24,95 +30,161 @@ hide:
 <td valign="top"><a href="#string">String</a>!</td>
 <td>
 
-Hello world demo
+Liveness check — returns a static "hello world" string. Useful for
+smoke-testing that the GraphQL server is reachable.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="queryroot.graph">graph</strong></td>
-<td valign="top"><a href="#graph">Graph</a>!</td>
+<td valign="top"><a href="#graph">Graph</a></td>
 <td>
 
-Returns a graph
+Load a graph by path. Returns null if the graph doesn't exist or is
+inaccessible. When a READ-scoped filter is attached to the caller's
+permissions, that filter is applied before the graph is returned.
+`graphType` lets you re-interpret the stored graph at query time —
+e.g. read an event-stored graph through persistent semantics. Defaults
+to the type the graph was created with.
+Requires READ on the graph.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">path</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Graph path relative to the root namespace (e.g. `"master"` or `"team/project/graph"`).
+
+</td>
+</tr>
+<tr>
+<td colspan="2" align="right" valign="top">graphType</td>
+<td valign="top"><a href="#graphtype">GraphType</a></td>
+<td>
+
+Optional override for graph semantics — `EVENT` treats every update as a point-in-time event, `PERSISTENT` carries values forward until overwritten or deleted. Defaults to the stored graph's native type.
+
+</td>
+</tr>
+<tr>
+<td colspan="2" valign="top"><strong id="queryroot.graphmetadata">graphMetadata</strong></td>
+<td valign="top"><a href="#metagraph">MetaGraph</a></td>
+<td>
+
+Returns lightweight metadata for a graph (node/edge counts,
+timestamps) without deserialising the full graph. Returns null if the
+graph doesn't exist or is inaccessible.
+Requires READ on the graph, or INTROSPECT on its parent namespace.
+
+</td>
+</tr>
+<tr>
+<td colspan="2" align="right" valign="top">path</td>
+<td valign="top"><a href="#string">String</a>!</td>
+<td>
+
+Graph path relative to the root namespace.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="queryroot.updategraph">updateGraph</strong></td>
 <td valign="top"><a href="#mutablegraph">MutableGraph</a>!</td>
 <td>
 
-Update graph query, has side effects to update graph state
-
-Returns:: GqlMutableGraph
+Open a graph for writing — returns a `MutableGraph` handle that can
+add nodes/edges/properties/metadata.
+Requires WRITE on the graph.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">path</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Graph path relative to the root namespace.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="queryroot.vectorisegraph">vectoriseGraph</strong></td>
 <td valign="top"><a href="#boolean">Boolean</a>!</td>
 <td>
 
-Update graph query, has side effects to update graph state
-
-Returns:: GqlMutableGraph
+Compute and persist embeddings for the nodes and edges of a stored
+graph so it can be queried via `vectorisedGraph`.
+Requires WRITE access.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">path</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Graph path relative to the root namespace.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">model</td>
 <td valign="top"><a href="#embeddingmodel">EmbeddingModel</a></td>
-<td></td>
+<td>
+
+Optional embedding model; defaults to OpenAI's standard model.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">nodes</td>
 <td valign="top"><a href="#template">Template</a></td>
-<td></td>
+<td>
+
+Optional node-document template (which fields go into each node's text representation); defaults to the built-in template.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">edges</td>
 <td valign="top"><a href="#template">Template</a></td>
-<td></td>
+<td>
+
+Optional edge-document template; defaults to the built-in template.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="queryroot.vectorisedgraph">vectorisedGraph</strong></td>
 <td valign="top"><a href="#vectorisedgraph">VectorisedGraph</a></td>
 <td>
 
-Create vectorised graph in the format used for queries
-
-Returns:: GqlVectorisedGraph
+Open a previously-vectorised graph for similarity queries. Returns null
+if the graph has no embeddings (call `vectoriseGraph` first) or is
+inaccessible.
+Requires READ on the graph.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">path</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Graph path relative to the root namespace.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="queryroot.namespaces">namespaces</strong></td>
 <td valign="top"><a href="#collectionofnamespace">CollectionOfNamespace</a>!</td>
 <td>
 
-Returns all namespaces using recursive search
-
-Returns::  List of namespaces on root
+Recursively list every namespace under the root. Each namespace is
+filtered against the caller's permissions: only namespaces with at
+least DISCOVER are returned.
 
 </td>
 </tr>
@@ -121,25 +193,29 @@ Returns::  List of namespaces on root
 <td valign="top"><a href="#namespace">Namespace</a>!</td>
 <td>
 
-Returns a specific namespace at a given path
-
-Returns:: Namespace or error if no namespace found
+Return a specific namespace by path. Errors if no namespace exists at
+that path.
+Requires INTROSPECT on the namespace to browse its contents.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">path</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Namespace path relative to the root namespace (e.g. `"team/project"`).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="queryroot.root">root</strong></td>
 <td valign="top"><a href="#namespace">Namespace</a>!</td>
 <td>
 
-Returns root namespace
-
-Returns::  Root namespace
+Returns the root namespace. Use it as the entry point for browsing
+namespaces and graphs — child listings filter against the caller's
+permissions.
 
 </td>
 </tr>
@@ -148,7 +224,9 @@ Returns::  Root namespace
 <td valign="top"><a href="#queryplugin">QueryPlugin</a>!</td>
 <td>
 
-Returns a plugin.
+Entry point for READ-only plugins registered with the server (e.g. graph
+algorithms exposed as queries). Available plugins are defined at server
+startup via the plugin registry.
 
 </td>
 </tr>
@@ -157,21 +235,30 @@ Returns a plugin.
 <td valign="top"><a href="#string">String</a>!</td>
 <td>
 
-Encodes graph and returns as string
-
-Returns:: Base64 url safe encoded string
+Encode a stored graph as a base64 string for client-side download. If
+a READ-scoped filter is attached to the caller's permissions, only the
+materialised filtered view is encoded.
+Requires READ on the graph.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">path</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Graph path relative to the root namespace.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="queryroot.version">version</strong></td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Version string of the running `raphtory-graphql` server build.
+
+</td>
 </tr>
 </tbody>
 </table>
@@ -201,28 +288,39 @@ Returns a collection of mutation plugins.
 <td valign="top"><a href="#boolean">Boolean</a>!</td>
 <td>
 
-Delete graph from a path on the server.
+Permanently delete a stored graph from the server.
+Requires WRITE on the graph and on its parent namespace.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">path</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Graph path relative to the root namespace.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="mutroot.newgraph">newGraph</strong></td>
 <td valign="top"><a href="#boolean">Boolean</a>!</td>
 <td>
 
-Creates a new graph.
+Create a new empty graph at the given path. Errors if a graph already
+exists there.
+Requires WRITE on the parent namespace.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">path</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Destination path relative to the root namespace.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">graphType</td>
@@ -234,154 +332,238 @@ Creates a new graph.
 <td valign="top"><a href="#boolean">Boolean</a>!</td>
 <td>
 
-Move graph from a path path on the server to a new_path on the server.
-
-If namespace is not provided, it will be set to the current working directory.
-This applies to both the graph namespace and new graph namespace.
+Move a stored graph to a new path on the server (rename / relocate).
+Atomic: copies first, then deletes the source.
+Requires WRITE on the source graph and on both the source and
+destination namespaces.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">path</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Current graph path relative to the root namespace.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">newPath</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Destination path relative to the root namespace.
+
+</td>
+</tr>
+<tr>
+<td colspan="2" align="right" valign="top">overwrite</td>
+<td valign="top"><a href="#boolean">Boolean</a></td>
+<td>
+
+If true, allow replacing an existing graph at `newPath`; defaults to false.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="mutroot.copygraph">copyGraph</strong></td>
 <td valign="top"><a href="#boolean">Boolean</a>!</td>
 <td>
 
-Copy graph from a path path on the server to a new_path on the server.
-
-If namespace is not provided, it will be set to the current working directory.
-This applies to both the graph namespace and new graph namespace.
+Duplicate a stored graph to a new path on the server. Source is
+preserved.
+Requires READ on the source graph and WRITE on the destination namespace.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">path</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Source graph path relative to the root namespace.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">newPath</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Destination path relative to the root namespace.
+
+</td>
+</tr>
+<tr>
+<td colspan="2" align="right" valign="top">overwrite</td>
+<td valign="top"><a href="#boolean">Boolean</a></td>
+<td>
+
+If true, allow replacing an existing graph at `newPath`; defaults to false.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="mutroot.uploadgraph">uploadGraph</strong></td>
 <td valign="top"><a href="#string">String</a>!</td>
 <td>
 
-Upload a graph file from a path on the client using GQL multipart uploading.
-
-Returns::
-name of the new graph
+Stream-upload a graph file using GraphQL multipart upload. The client
+sends the file directly; the server stores it under `path`.
+Requires WRITE on the destination namespace.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">path</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Destination path relative to the root namespace.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">graph</td>
 <td valign="top"><a href="#upload">Upload</a>!</td>
-<td></td>
+<td>
+
+Multipart upload of the serialised graph file.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">overwrite</td>
 <td valign="top"><a href="#boolean">Boolean</a>!</td>
-<td></td>
+<td>
+
+If true, replace any graph already at `path`.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="mutroot.sendgraph">sendGraph</strong></td>
 <td valign="top"><a href="#string">String</a>!</td>
 <td>
 
-Send graph bincode as base64 encoded string.
-
-Returns::
-path of the new graph
+Send a serialised graph as a base64-encoded string in the request
+body. Use for smaller graphs where multipart upload is overkill.
+Requires WRITE on the destination namespace.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">path</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Destination path relative to the root namespace.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">graph</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Base64-encoded bincode of the serialised graph.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">overwrite</td>
 <td valign="top"><a href="#boolean">Boolean</a>!</td>
-<td></td>
+<td>
+
+If true, replace any graph already at `path`.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="mutroot.createsubgraph">createSubgraph</strong></td>
 <td valign="top"><a href="#string">String</a>!</td>
 <td>
 
-Returns a subgraph given a set of nodes from an existing graph in the server.
-
-Returns::
-name of the new graph
+Persist a subgraph of an existing stored graph as a new graph. The
+subgraph contains only the listed nodes and edges between them.
+Requires READ on the parent graph and WRITE on the destination namespace.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">parentPath</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Source graph path relative to the root namespace.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">nodes</td>
-<td valign="top">[<a href="#string">String</a>!]!</td>
-<td></td>
+<td valign="top">[<a href="#nodeid">NodeId</a>!]!</td>
+<td>
+
+Node ids to include in the subgraph.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">newPath</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Destination path relative to the root namespace.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">overwrite</td>
 <td valign="top"><a href="#boolean">Boolean</a>!</td>
-<td></td>
+<td>
+
+If true, replace any graph already at `newPath`.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="mutroot.createindex">createIndex</strong></td>
 <td valign="top"><a href="#boolean">Boolean</a>!</td>
 <td>
 
-(Experimental) Creates search index.
+(Experimental) Build a Tantivy search index for a stored graph so it
+can be queried via `searchNodes` / `searchEdges`.
+Requires WRITE on the graph.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">path</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Graph path relative to the root namespace.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">indexSpec</td>
 <td valign="top"><a href="#indexspecinput">IndexSpecInput</a></td>
-<td></td>
+<td>
+
+Optional spec selecting which node/edge property fields to index. Omit to index a default set.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">inRam</td>
 <td valign="top"><a href="#boolean">Boolean</a>!</td>
-<td></td>
+<td>
+
+If true, build the index in memory (faster but lost on restart). If false, persist to disk.
+
+</td>
 </tr>
 </tbody>
 </table>
@@ -426,17 +608,29 @@ will be returned.
 <tr>
 <td colspan="2" align="right" valign="top">limit</td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Maximum number of items to return on this page.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">offset</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Extra items to skip on top of `pageIndex` paging (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">pageIndex</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Zero-based page number; multiplies `limit` to determine where to start (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="collectionofmetagraph.count">count</strong></td>
@@ -488,17 +682,29 @@ will be returned.
 <tr>
 <td colspan="2" align="right" valign="top">limit</td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Maximum number of items to return on this page.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">offset</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Extra items to skip on top of `pageIndex` paging (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">pageIndex</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Zero-based page number; multiplies `limit` to determine where to start (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="collectionofnamespace.count">count</strong></td>
@@ -550,17 +756,29 @@ will be returned.
 <tr>
 <td colspan="2" align="right" valign="top">limit</td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Maximum number of items to return on this page.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">offset</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Extra items to skip on top of `pageIndex` paging (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">pageIndex</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Zero-based page number; multiplies `limit` to determine where to start (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="collectionofnamespaceditem.count">count</strong></td>
@@ -660,7 +878,11 @@ Errors if any of the layers do not exist.
 <tr>
 <td colspan="2" align="right" valign="top">names</td>
 <td valign="top">[<a href="#string">String</a>!]!</td>
-<td></td>
+<td>
+
+Layer names to include.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edge.excludelayers">excludeLayers</strong></td>
@@ -676,7 +898,11 @@ Errors if any of the layers do not exist.
 <tr>
 <td colspan="2" align="right" valign="top">names</td>
 <td valign="top">[<a href="#string">String</a>!]!</td>
-<td></td>
+<td>
+
+Layer names to exclude.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edge.layer">layer</strong></td>
@@ -692,9 +918,13 @@ Errors if any of the layers do not exist.
 <tr>
 <td colspan="2" align="right" valign="top">name</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
-</tr>
-<tr>
+<td>
+
+Layer name to include.
+
+</td>
+</tr>
+<tr>
 <td colspan="2" valign="top"><strong id="edge.excludelayer">excludeLayer</strong></td>
 <td valign="top"><a href="#edge">Edge</a>!</td>
 <td>
@@ -708,7 +938,11 @@ Errors if any of the layers do not exist.
 <tr>
 <td colspan="2" align="right" valign="top">name</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Layer name to exclude.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edge.rolling">rolling</strong></td>
@@ -730,17 +964,29 @@ the start of the first window and/or after the end of the last window (i.e. not
 <tr>
 <td colspan="2" align="right" valign="top">window</td>
 <td valign="top"><a href="#windowduration">WindowDuration</a>!</td>
-<td></td>
+<td>
+
+Width of each window. Pass either `{epoch: <ms>}` for a discrete number of milliseconds (e.g. `{epoch: 1000}` for 1 second), or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}` or `{duration: 2 hours and 30 minutes}`).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">step</td>
 <td valign="top"><a href="#windowduration">WindowDuration</a></td>
-<td></td>
+<td>
+
+Optional gap between the start of one window and the start of the next. Accepts the same `{epoch: <ms>}` or `{duration: <text>}` values as `window`. Defaults to `window` — i.e. windows touch end-to-end with no overlap and no gap.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">alignmentUnit</td>
 <td valign="top"><a href="#alignmentunit">AlignmentUnit</a></td>
-<td></td>
+<td>
+
+Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step` (or `window` if no step is set).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edge.expanding">expanding</strong></td>
@@ -760,12 +1006,20 @@ e.g. "1 month and 1 day" will align at the start of the day.
 <tr>
 <td colspan="2" align="right" valign="top">step</td>
 <td valign="top"><a href="#windowduration">WindowDuration</a>!</td>
-<td></td>
+<td>
+
+How much the window grows by on each step. Pass either `{epoch: <ms>}` for a discrete number of milliseconds, or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}`).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">alignmentUnit</td>
 <td valign="top"><a href="#alignmentunit">AlignmentUnit</a></td>
-<td></td>
+<td>
+
+Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step`.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edge.window">window</strong></td>
@@ -781,12 +1035,20 @@ For persistent graphs, any edge which exists at any point during the window will
 <tr>
 <td colspan="2" align="right" valign="top">start</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Inclusive lower bound.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">end</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Exclusive upper bound.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edge.at">at</strong></td>
@@ -800,14 +1062,21 @@ Creates a view of the Edge including all events at a specified time.
 <tr>
 <td colspan="2" align="right" valign="top">time</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Instant to pin the view to.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edge.latest">latest</strong></td>
 <td valign="top"><a href="#edge">Edge</a>!</td>
 <td>
 
-Returns a view of the edge at the latest time of the graph.
+View of this edge pinned to the graph's latest time — equivalent to
+`at(graph.latestTime)`. The edge's properties and metadata show their
+most recent values, and (for persistent graphs) validity is evaluated
+at that instant.
 
 </td>
 </tr>
@@ -825,7 +1094,11 @@ This is equivalent to before(time + 1) for Graph and at(time) for PersistentGrap
 <tr>
 <td colspan="2" align="right" valign="top">time</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Instant at which entities must be valid.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edge.snapshotlatest">snapshotLatest</strong></td>
@@ -850,7 +1123,11 @@ Creates a view of the Edge including all events before a specified end (exclusiv
 <tr>
 <td colspan="2" align="right" valign="top">time</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Exclusive upper bound.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edge.after">after</strong></td>
@@ -864,7 +1141,11 @@ Creates a view of the Edge including all events after a specified start (exclusi
 <tr>
 <td colspan="2" align="right" valign="top">time</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Exclusive lower bound.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edge.shrinkwindow">shrinkWindow</strong></td>
@@ -878,12 +1159,20 @@ Shrinks both the start and end of the window.
 <tr>
 <td colspan="2" align="right" valign="top">start</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Proposed new start (TimeInput); ignored if it would widen the window.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">end</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Proposed new end (TimeInput); ignored if it would widen the window.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edge.shrinkstart">shrinkStart</strong></td>
@@ -897,7 +1186,11 @@ Set the start of the window.
 <tr>
 <td colspan="2" align="right" valign="top">start</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Proposed new start (TimeInput); ignored if it would widen the window.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edge.shrinkend">shrinkEnd</strong></td>
@@ -911,7 +1204,11 @@ Set the end of the window.
 <tr>
 <td colspan="2" align="right" valign="top">end</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Proposed new end (TimeInput); ignored if it would widen the window.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edge.applyviews">applyViews</strong></td>
@@ -925,7 +1222,11 @@ Takes a specified selection of views and applies them in given order.
 <tr>
 <td colspan="2" align="right" valign="top">views</td>
 <td valign="top">[<a href="#edgeviewcollection">EdgeViewCollection</a>!]!</td>
-<td></td>
+<td>
+
+Ordered list of view operations; each entry is a one-of variant (`window`, `layer`, `filter`, ...) applied to the running result.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edge.earliesttime">earliestTime</strong></td>
@@ -939,7 +1240,14 @@ Returns the earliest time of an edge.
 <tr>
 <td colspan="2" valign="top"><strong id="edge.firstupdate">firstUpdate</strong></td>
 <td valign="top"><a href="#eventtime">EventTime</a>!</td>
-<td></td>
+<td>
+
+The timestamp of the first event in this edge's history (first update, first
+deletion, or anything in between). Differs from `earliestTime` in that
+`earliestTime` reports when the edge is first *valid*; `firstUpdate` reports
+when its history actually begins.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edge.latesttime">latestTime</strong></td>
@@ -953,7 +1261,14 @@ Returns the latest time of an edge.
 <tr>
 <td colspan="2" valign="top"><strong id="edge.lastupdate">lastUpdate</strong></td>
 <td valign="top"><a href="#eventtime">EventTime</a>!</td>
-<td></td>
+<td>
+
+The timestamp of the last event in this edge's history (last update, last
+deletion, or anything in between). Differs from `latestTime` in that
+`latestTime` reports when the edge is last *valid*; `lastUpdate` reports
+when its history actually ends.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edge.time">time</strong></td>
@@ -1020,13 +1335,12 @@ Node:
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edge.id">id</strong></td>
-<td valign="top">[<a href="#string">String</a>!]!</td>
+<td valign="top">[<a href="#nodeid">NodeId</a>!]!</td>
 <td>
 
-Returns the id of the edge.
-
-Returns:
-list[str]:
+Returns the `[src, dst]` id pair of the edge. Each id is a `String`
+for string-indexed graphs or a non-negative `Int` for integer-indexed
+graphs.
 
 </td>
 </tr>
@@ -1157,18 +1471,31 @@ Returns: boolean
 <tr>
 <td colspan="2" valign="top"><strong id="edge.filter">filter</strong></td>
 <td valign="top"><a href="#edge">Edge</a>!</td>
-<td></td>
+<td>
+
+Apply an edge filter in place, returning an edge view whose properties /
+metadata / history are restricted to the matching subset.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">expr</td>
 <td valign="top"><a href="#edgefilter">EdgeFilter</a>!</td>
-<td></td>
+<td>
+
+Composite edge filter (by property, layer, src/dst, etc.).
+
+</td>
 </tr>
 </tbody>
 </table>
 
 ### EdgeSchema
 
+Describes edges between a specific pair of node types — the property and
+metadata keys seen on such edges, along with their observed value types.
+One `EdgeSchema` per `(srcType, dstType)` pair per layer.
+
 <table>
 <thead>
 <tr>
@@ -1220,6 +1547,10 @@ Returns the list of metadata schemas for edges connecting these types of nodes
 
 ### EdgeWindowSet
 
+A lazy sequence of per-window views of a single edge, produced by
+`edge.rolling` / `edge.expanding`. Each entry is the edge as it exists in
+that window.
+
 <table>
 <thead>
 <tr>
@@ -1233,7 +1564,12 @@ Returns the list of metadata schemas for edges connecting these types of nodes
 <tr>
 <td colspan="2" valign="top"><strong id="edgewindowset.count">count</strong></td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Number of windows in this set. Materialising all windows is expensive for
+large graphs — prefer `page` over `list` when iterating.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edgewindowset.page">page</strong></td>
@@ -1251,28 +1587,49 @@ will be returned.
 <tr>
 <td colspan="2" align="right" valign="top">limit</td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Maximum number of items to return on this page.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">offset</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Extra items to skip on top of `pageIndex` paging (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">pageIndex</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Zero-based page number; multiplies `limit` to determine where to start (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edgewindowset.list">list</strong></td>
 <td valign="top">[<a href="#edge">Edge</a>!]!</td>
-<td></td>
+<td>
+
+Materialise every window as a list. Rejected by the server when bulk list
+endpoints are disabled; use `page` for paginated access instead.
+
+</td>
 </tr>
 </tbody>
 </table>
 
 ### Edges
 
+A lazy collection of edges from a graph view. Supports the usual view
+transforms (window, layer, filter, ...), plus edge-specific ones like
+`explode` and `explodeLayers`, pagination, and sorting.
+
 <table>
 <thead>
 <tr>
@@ -1304,7 +1661,11 @@ Returns a collection containing only edges belonging to the listed layers.
 <tr>
 <td colspan="2" align="right" valign="top">names</td>
 <td valign="top">[<a href="#string">String</a>!]!</td>
-<td></td>
+<td>
+
+Layer names to include.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edges.excludelayers">excludeLayers</strong></td>
@@ -1318,7 +1679,11 @@ Returns a collection containing edges belonging to all layers except the exclude
 <tr>
 <td colspan="2" align="right" valign="top">names</td>
 <td valign="top">[<a href="#string">String</a>!]!</td>
-<td></td>
+<td>
+
+Layer names to exclude.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edges.layer">layer</strong></td>
@@ -1332,7 +1697,11 @@ Returns a collection containing edges belonging to the specified layer.
 <tr>
 <td colspan="2" align="right" valign="top">name</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Layer name to include.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edges.excludelayer">excludeLayer</strong></td>
@@ -1346,7 +1715,11 @@ Returns a collection containing edges belonging to all layers except the exclude
 <tr>
 <td colspan="2" align="right" valign="top">name</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Layer name to exclude.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edges.rolling">rolling</strong></td>
@@ -1368,17 +1741,29 @@ the start of the first window and/or after the end of the last window (i.e. not
 <tr>
 <td colspan="2" align="right" valign="top">window</td>
 <td valign="top"><a href="#windowduration">WindowDuration</a>!</td>
-<td></td>
+<td>
+
+Width of each window. Pass either `{epoch: <ms>}` for a discrete number of milliseconds (e.g. `{epoch: 1000}` for 1 second), or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}` or `{duration: 2 hours and 30 minutes}`).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">step</td>
 <td valign="top"><a href="#windowduration">WindowDuration</a></td>
-<td></td>
+<td>
+
+Optional gap between the start of one window and the start of the next. Accepts the same `{epoch: <ms>}` or `{duration: <text>}` values as `window`. Defaults to `window` — i.e. windows touch end-to-end with no overlap and no gap.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">alignmentUnit</td>
 <td valign="top"><a href="#alignmentunit">AlignmentUnit</a></td>
-<td></td>
+<td>
+
+Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step` (or `window` if no step is set).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edges.expanding">expanding</strong></td>
@@ -1398,12 +1783,20 @@ e.g. "1 month and 1 day" will align at the start of the day.
 <tr>
 <td colspan="2" align="right" valign="top">step</td>
 <td valign="top"><a href="#windowduration">WindowDuration</a>!</td>
-<td></td>
+<td>
+
+How much the window grows by on each step. Pass either `{epoch: <ms>}` for a discrete number of milliseconds, or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}`).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">alignmentUnit</td>
 <td valign="top"><a href="#alignmentunit">AlignmentUnit</a></td>
-<td></td>
+<td>
+
+Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step`.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edges.window">window</strong></td>
@@ -1417,12 +1810,20 @@ Creates a view of the Edge including all events between the specified start (inc
 <tr>
 <td colspan="2" align="right" valign="top">start</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Inclusive lower bound.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">end</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Exclusive upper bound.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edges.at">at</strong></td>
@@ -1436,12 +1837,20 @@ Creates a view of the Edge including all events at a specified time.
 <tr>
 <td colspan="2" align="right" valign="top">time</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Instant to pin the view to.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edges.latest">latest</strong></td>
 <td valign="top"><a href="#edges">Edges</a>!</td>
-<td></td>
+<td>
+
+View showing only the latest state of each edge (equivalent to `at(latestTime)`).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edges.snapshotat">snapshotAt</strong></td>
@@ -1455,7 +1864,11 @@ Creates a view of the Edge including all events that are valid at time. This is
 <tr>
 <td colspan="2" align="right" valign="top">time</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Instant at which entities must be valid.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edges.snapshotlatest">snapshotLatest</strong></td>
@@ -1478,7 +1891,11 @@ Creates a view of the Edge including all events before a specified end (exclusiv
 <tr>
 <td colspan="2" align="right" valign="top">time</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Exclusive upper bound.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edges.after">after</strong></td>
@@ -1492,7 +1909,11 @@ Creates a view of the Edge including all events after a specified start (exclusi
 <tr>
 <td colspan="2" align="right" valign="top">time</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Exclusive lower bound.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edges.shrinkwindow">shrinkWindow</strong></td>
@@ -1506,12 +1927,20 @@ Shrinks both the start and end of the window.
 <tr>
 <td colspan="2" align="right" valign="top">start</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Proposed new start (TimeInput); ignored if it would widen the window.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">end</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Proposed new end (TimeInput); ignored if it would widen the window.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edges.shrinkstart">shrinkStart</strong></td>
@@ -1525,7 +1954,11 @@ Set the start of the window.
 <tr>
 <td colspan="2" align="right" valign="top">start</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Proposed new start (TimeInput); ignored if it would widen the window.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edges.shrinkend">shrinkEnd</strong></td>
@@ -1539,7 +1972,11 @@ Set the end of the window.
 <tr>
 <td colspan="2" align="right" valign="top">end</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Proposed new end (TimeInput); ignored if it would widen the window.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edges.applyviews">applyViews</strong></td>
@@ -1553,14 +1990,20 @@ Takes a specified selection of views and applies them in order given.
 <tr>
 <td colspan="2" align="right" valign="top">views</td>
 <td valign="top">[<a href="#edgesviewcollection">EdgesViewCollection</a>!]!</td>
-<td></td>
+<td>
+
+Ordered list of view operations; each entry is a one-of variant (`window`, `layer`, `filter`, ...) applied to the running result.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edges.explode">explode</strong></td>
 <td valign="top"><a href="#edges">Edges</a>!</td>
 <td>
 
-Returns an edge object for each update within the original edge.
+Expand each edge into one edge per update: if `A->B` has three updates, it
+becomes three `A->B` entries each at a distinct timestamp. Use this to
+iterate per-event rather than per-edge.
 
 </td>
 </tr>
@@ -1580,14 +2023,19 @@ Each new edge object contains only updates from the respective layers.
 <td valign="top"><a href="#edges">Edges</a>!</td>
 <td>
 
-Specify a sort order from: source, destination, property, time. You can also reverse the ordering.
+Sort the edges. Multiple criteria are applied lexicographically (ties
+on the first key break to the second, etc.).
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">sortBys</td>
 <td valign="top">[<a href="#edgesortby">EdgeSortBy</a>!]!</td>
-<td></td>
+<td>
+
+Ordered list of sort keys. Each entry chooses exactly one of `src` / `dst` / `time` / `property`, with an optional `reverse: true` to flip order.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edges.start">start</strong></td>
@@ -1635,17 +2083,29 @@ will be returned.
 <tr>
 <td colspan="2" align="right" valign="top">limit</td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
-</tr>
+<td>
+
+Maximum number of items to return on this page.
+
+</td>
+</tr>
 <tr>
 <td colspan="2" align="right" valign="top">offset</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Extra items to skip on top of `pageIndex` paging (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">pageIndex</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Zero-based page number; multiplies `limit` to determine where to start (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edges.list">list</strong></td>
@@ -1661,34 +2121,77 @@ Returns a list of all objects in the current selection of the collection. You sh
 <td valign="top"><a href="#edges">Edges</a>!</td>
 <td>
 
-Returns a filtered view that applies to list down the chain
+Narrow the collection to edges matching `expr`. The filter sticks to the
+returned view — every subsequent traversal through these edges (their
+properties, their endpoints' neighbours, etc.) continues to see the
+filtered scope.
+
+Useful when you want one scoping rule to apply across the whole query.
+E.g. restricting everything to a specific week:
+
+```text
+edges { filter(expr: {window: {start: 1234, end: 5678}}) {
+list { src { neighbours { list { name } } } }   # neighbours still windowed
+} }
+```
+
+Contrast with `select`, which applies here and is not carried through.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">expr</td>
 <td valign="top"><a href="#edgefilter">EdgeFilter</a>!</td>
-<td></td>
+<td>
+
+Composite edge filter (by property, layer, src/dst, etc.).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edges.select">select</strong></td>
 <td valign="top"><a href="#edges">Edges</a>!</td>
 <td>
 
-Returns filtered list of edges
+Narrow the collection to edges matching `expr`, but only at this step —
+subsequent traversals out of these edges see the unfiltered graph again.
+
+Useful when you want different scopes at different hops. E.g. Monday's
+edges, then the neighbours of their endpoints on Tuesday, then *those*
+neighbours on Wednesday:
+
+```text
+edges { select(expr: {window: {...monday...}}) {
+list { src { select(expr: {window: {...tuesday...}}) {
+neighbours { select(expr: {window: {...wednesday...}}) {
+neighbours { list { name } }
+} }
+} } }
+} }
+```
+
+Contrast with `filter`, which persists the scope through subsequent ops.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">expr</td>
 <td valign="top"><a href="#edgefilter">EdgeFilter</a>!</td>
-<td></td>
+<td>
+
+Composite edge filter (by property, layer, src/dst, etc.).
+
+</td>
 </tr>
 </tbody>
 </table>
 
 ### EdgesWindowSet
 
+A lazy sequence of per-window edge collections, produced by
+`edges.rolling` / `edges.expanding`. Each entry is an `Edges` collection
+as it exists in that window.
+
 <table>
 <thead>
 <tr>
@@ -1702,7 +2205,12 @@ Returns filtered list of edges
 <tr>
 <td colspan="2" valign="top"><strong id="edgeswindowset.count">count</strong></td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Number of windows in this set. Materialising all windows is expensive for
+large graphs — prefer `page` over `list` when iterating.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edgeswindowset.page">page</strong></td>
@@ -1720,22 +2228,39 @@ will be returned.
 <tr>
 <td colspan="2" align="right" valign="top">limit</td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Maximum number of items to return on this page.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">offset</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Extra items to skip on top of `pageIndex` paging (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">pageIndex</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Zero-based page number; multiplies `limit` to determine where to start (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edgeswindowset.list">list</strong></td>
 <td valign="top">[<a href="#edges">Edges</a>!]!</td>
-<td></td>
+<td>
+
+Materialise every window as a list. Rejected by the server when bulk list
+endpoints are disabled; use `page` for paginated access instead.
+
+</td>
 </tr>
 </tbody>
 </table>
@@ -1797,13 +2322,21 @@ Raises an error if a time conversion fails.
 <tr>
 <td colspan="2" align="right" valign="top">formatString</td>
 <td valign="top"><a href="#string">String</a></td>
-<td></td>
+<td>
+
+Optional format string for the rendered datetime. Uses `%`-style specifiers — for example `%Y-%m-%d` for `2024-01-15`, `%Y-%m-%d %H:%M:%S` for `2024-01-15 10:30:00`, or `%H:%M` for `10:30`. Defaults to RFC 3339 (e.g. `2024-01-15T10:30:45.123+00:00`) when omitted.
+
+</td>
 </tr>
 </tbody>
 </table>
 
 ### Graph
 
+A view of a Raphtory graph. Every field here returns either data from the
+view or a derived view (`window`, `layer`, `at`, `filter`, ...) that you can
+keep chaining. Views are cheap — they don't copy the underlying data.
+
 <table>
 <thead>
 <tr>
@@ -1820,6 +2353,9 @@ Raises an error if a time conversion fails.
 <td>
 
 Returns the names of all layers in the graphview.
+Distinct layer names observed in the current view — any layer that has at
+least one edge event visible here. Excludes layers that exist elsewhere in
+the graph but whose edges have been filtered out.
 
 </td>
 </tr>
@@ -1828,7 +2364,10 @@ Returns the names of all layers in the graphview.
 <td valign="top"><a href="#graph">Graph</a>!</td>
 <td>
 
-Returns a view containing only the default layer.
+View restricted to the default layer — where nodes and edges end up
+when `addNode` / `addEdge` is called without a `layer` argument.
+Useful for separating "unlayered" base-graph events from named-layer
+ones.
 
 </td>
 </tr>
@@ -1837,77 +2376,109 @@ Returns a view containing only the default layer.
 <td valign="top"><a href="#graph">Graph</a>!</td>
 <td>
 
-Returns a view containing all the specified layers.
+View restricted to the named layers. Updates on any other layer are hidden;
+if that leaves a node or edge with no updates left, it disappears from the
+view.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">names</td>
 <td valign="top">[<a href="#string">String</a>!]!</td>
-<td></td>
+<td>
+
+Layer names to include.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="graph.excludelayers">excludeLayers</strong></td>
 <td valign="top"><a href="#graph">Graph</a>!</td>
 <td>
 
-Returns a view containing all layers except the specified excluded layers.
+View with the named layers hidden. Updates on those layers are removed; if
+that leaves a node or edge with no updates left, it disappears from the
+view.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">names</td>
 <td valign="top">[<a href="#string">String</a>!]!</td>
-<td></td>
+<td>
+
+Layer names to exclude.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="graph.layer">layer</strong></td>
 <td valign="top"><a href="#graph">Graph</a>!</td>
 <td>
 
-Returns a view containing the layer specified.
+View restricted to a single layer. Convenience form of
+`layers(names: [name])` — updates on any other layer are hidden, and
+entities with nothing left disappear.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">name</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Layer name to include.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="graph.excludelayer">excludeLayer</strong></td>
 <td valign="top"><a href="#graph">Graph</a>!</td>
 <td>
 
-Returns a view containing all layers except the specified excluded layer.
+View with one layer hidden. Convenience form of
+`excludeLayers(names: [name])` — updates on that layer are removed, and
+entities with nothing left disappear.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">name</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Layer name to exclude.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="graph.subgraph">subgraph</strong></td>
 <td valign="top"><a href="#graph">Graph</a>!</td>
 <td>
 
-Returns a subgraph of a specified set of nodes which contains only the edges that connect nodes of the subgraph to each other.
+View restricted to a chosen set of nodes and the edges between them. Edges
+connecting a selected node to a non-selected node are hidden.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">nodes</td>
-<td valign="top">[<a href="#string">String</a>!]!</td>
-<td></td>
+<td valign="top">[<a href="#nodeid">NodeId</a>!]!</td>
+<td>
+
+Node ids to keep.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="graph.valid">valid</strong></td>
 <td valign="top"><a href="#graph">Graph</a>!</td>
 <td>
 
-Returns a view of the graph that only includes valid edges.
+View containing only valid edges — for persistent graphs this drops edges
+whose most recent event is a deletion at the latest time of the current
+view (a later re-addition would keep them). On event graphs this is a
+no-op.
 
 </td>
 </tr>
@@ -1916,28 +2487,36 @@ Returns a view of the graph that only includes valid edges.
 <td valign="top"><a href="#graph">Graph</a>!</td>
 <td>
 
-Returns a subgraph filtered by the specified node types.
+View restricted to nodes with the given node types.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">nodeTypes</td>
 <td valign="top">[<a href="#string">String</a>!]!</td>
-<td></td>
+<td>
+
+Node types to include.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="graph.excludenodes">excludeNodes</strong></td>
 <td valign="top"><a href="#graph">Graph</a>!</td>
 <td>
 
-Returns a subgraph containing all nodes except the specified excluded nodes.
+View with a set of nodes removed (along with any edges touching them).
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">nodes</td>
-<td valign="top">[<a href="#string">String</a>!]!</td>
-<td></td>
+<td valign="top">[<a href="#nodeid">NodeId</a>!]!</td>
+<td>
+
+Node ids to exclude.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="graph.rolling">rolling</strong></td>
@@ -1959,17 +2538,29 @@ the start of the first window and/or after the end of the last window (i.e. not
 <tr>
 <td colspan="2" align="right" valign="top">window</td>
 <td valign="top"><a href="#windowduration">WindowDuration</a>!</td>
-<td></td>
+<td>
+
+Width of each window. Pass either `{epoch: <ms>}` for a discrete number of milliseconds (e.g. `{epoch: 1000}` for 1 second), or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}` or `{duration: 2 hours and 30 minutes}`).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">step</td>
 <td valign="top"><a href="#windowduration">WindowDuration</a></td>
-<td></td>
+<td>
+
+Optional gap between the start of one window and the start of the next. Accepts the same `{epoch: <ms>}` or `{duration: <text>}` values as `window`. Defaults to `window` — i.e. windows touch end-to-end with no overlap and no gap.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">alignmentUnit</td>
 <td valign="top"><a href="#alignmentunit">AlignmentUnit</a></td>
-<td></td>
+<td>
+
+Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step` (or `window` if no step is set).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="graph.expanding">expanding</strong></td>
@@ -1989,12 +2580,20 @@ e.g. "1 month and 1 day" will align at the start of the day.
 <tr>
 <td colspan="2" align="right" valign="top">step</td>
 <td valign="top"><a href="#windowduration">WindowDuration</a>!</td>
-<td></td>
+<td>
+
+How much the window grows by on each step. Pass either `{epoch: <ms>}` for a discrete number of milliseconds, or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}`).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">alignmentUnit</td>
 <td valign="top"><a href="#alignmentunit">AlignmentUnit</a></td>
-<td></td>
+<td>
+
+Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step`.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="graph.window">window</strong></td>
@@ -2008,12 +2607,20 @@ Return a graph containing only the activity between start and end, by default ra
 <tr>
 <td colspan="2" align="right" valign="top">start</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Inclusive lower bound.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">end</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Exclusive upper bound.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="graph.at">at</strong></td>
@@ -2027,7 +2634,11 @@ Creates a view including all events at a specified time.
 <tr>
 <td colspan="2" align="right" valign="top">time</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Instant to pin the view to.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="graph.latest">latest</strong></td>
@@ -2050,7 +2661,11 @@ Create a view including all events that are valid at the specified time.
 <tr>
 <td colspan="2" align="right" valign="top">time</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Instant at which entities must be valid.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="graph.snapshotlatest">snapshotLatest</strong></td>
@@ -2073,7 +2688,11 @@ Create a view including all events before a specified end (exclusive).
 <tr>
 <td colspan="2" align="right" valign="top">time</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Exclusive upper bound.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="graph.after">after</strong></td>
@@ -2087,26 +2706,39 @@ Create a view including all events after a specified start (exclusive).
 <tr>
 <td colspan="2" align="right" valign="top">time</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Exclusive lower bound.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="graph.shrinkwindow">shrinkWindow</strong></td>
 <td valign="top"><a href="#graph">Graph</a>!</td>
 <td>
 
-Shrink both the start and end of the window.
+Shrink both the start and end of the window. The new bounds are taken as the
+intersection with the current window; this never widens the view.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">start</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Proposed new start (TimeInput); ignored if before the current start.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">end</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Proposed new end (TimeInput); ignored if after the current end.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="graph.shrinkstart">shrinkStart</strong></td>
@@ -2120,7 +2752,11 @@ Set the start of the window to the larger of the specified value or current star
 <tr>
 <td colspan="2" align="right" valign="top">start</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Proposed new start (TimeInput); has no effect if it would widen the window.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="graph.shrinkend">shrinkEnd</strong></td>
@@ -2134,14 +2770,20 @@ Set the end of the window to the smaller of the specified value or current end.
 <tr>
 <td colspan="2" align="right" valign="top">end</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Proposed new end (TimeInput); has no effect if it would widen the window.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="graph.created">created</strong></td>
 <td valign="top"><a href="#int">Int</a>!</td>
 <td>
 
-Returns the timestamp for the creation of the graph.
+Filesystem creation timestamp (epoch millis) of the graph's on-disk folder
+— i.e. when this graph was first saved to the server, not when its earliest
+event occurred. Use `earliestTime` for the latter.
 
 </td>
 </tr>
@@ -2204,28 +2846,39 @@ Returns the end time of the window. Errors if there is no window.
 <td valign="top"><a href="#eventtime">EventTime</a>!</td>
 <td>
 
-Returns the earliest time that any edge in this graph is valid.
+The earliest time at which any edge in this graph is valid.
+
+* `includeNegative` — if false, edge events with a timestamp `< 0` are
+skipped when computing the minimum. Defaults to true.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">includeNegative</td>
 <td valign="top"><a href="#boolean">Boolean</a></td>
-<td></td>
+<td>
+
+If false, edge events with a timestamp `< 0` are skipped when computing the minimum. Defaults to true.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="graph.latestedgetime">latestEdgeTime</strong></td>
 <td valign="top"><a href="#eventtime">EventTime</a>!</td>
 <td>
 
-Returns the latest time that any edge in this graph is valid.
+The latest time at which any edge in this graph is valid.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">includeNegative</td>
 <td valign="top"><a href="#boolean">Boolean</a></td>
-<td></td>
+<td>
+
+If false, edge events with a timestamp `< 0` are skipped when computing the maximum. Defaults to true.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="graph.countedges">countEdges</strong></td>
@@ -2264,99 +2917,138 @@ Optionally takes a list of node ids to return a subset.
 <td valign="top"><a href="#boolean">Boolean</a>!</td>
 <td>
 
-Returns true if the graph contains the specified node.
+Returns true if a node with the given id exists in this view.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">name</td>
-<td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td valign="top"><a href="#nodeid">NodeId</a>!</td>
+<td>
+
+Node id to look up.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="graph.hasedge">hasEdge</strong></td>
 <td valign="top"><a href="#boolean">Boolean</a>!</td>
 <td>
 
-Returns true if the graph contains the specified edge. Edges are specified by providing a source and destination node id. You can restrict the search to a specified layer.
+Returns true if an edge exists between `src` and `dst` in this view, optionally
+restricted to a single layer.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">src</td>
-<td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td valign="top"><a href="#nodeid">NodeId</a>!</td>
+<td>
+
+Source node id.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">dst</td>
-<td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td valign="top"><a href="#nodeid">NodeId</a>!</td>
+<td>
+
+Destination node id.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">layer</td>
 <td valign="top"><a href="#string">String</a></td>
-<td></td>
+<td>
+
+Optional; if provided, only checks whether the edge exists on this layer. If null or omitted, any layer counts.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="graph.node">node</strong></td>
 <td valign="top"><a href="#node">Node</a></td>
 <td>
 
-Gets the node with the specified id.
+Look up a single node by id. Returns null if the node doesn't exist in this
+view.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">name</td>
-<td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td valign="top"><a href="#nodeid">NodeId</a>!</td>
+<td>
+
+Node id.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="graph.nodes">nodes</strong></td>
 <td valign="top"><a href="#nodes">Nodes</a>!</td>
 <td>
 
-Gets (optionally a subset of) the nodes in the graph.
+All nodes in this view, optionally narrowed by a filter.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">select</td>
 <td valign="top"><a href="#nodefilter">NodeFilter</a></td>
-<td></td>
+<td>
+
+Optional node filter (by name, property, type, etc.). If omitted, every node in the view is returned.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="graph.edge">edge</strong></td>
 <td valign="top"><a href="#edge">Edge</a></td>
 <td>
 
-Gets the edge with the specified source and destination nodes.
+Look up a single edge by its endpoint ids. Returns null if no edge exists
+between `src` and `dst` in this view.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">src</td>
-<td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td valign="top"><a href="#nodeid">NodeId</a>!</td>
+<td>
+
+Source node id.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">dst</td>
-<td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td valign="top"><a href="#nodeid">NodeId</a>!</td>
+<td>
+
+Destination node id.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="graph.edges">edges</strong></td>
 <td valign="top"><a href="#edges">Edges</a>!</td>
 <td>
 
-Gets the edges in the graph.
+All edges in this view, optionally narrowed by a filter.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">select</td>
 <td valign="top"><a href="#edgefilter">EdgeFilter</a></td>
-<td></td>
+<td>
+
+Optional edge filter (by property, layer, src/dst, etc.). If omitted, every edge in the view is returned.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="graph.properties">properties</strong></td>
@@ -2415,61 +3107,109 @@ Returns the graph schema.
 <tr>
 <td colspan="2" valign="top"><strong id="graph.algorithms">algorithms</strong></td>
 <td valign="top"><a href="#graphalgorithmplugin">GraphAlgorithmPlugin</a>!</td>
-<td></td>
+<td>
+
+Access registered graph algorithms (PageRank, shortest path, etc.) for this
+graph view. The set of available algorithms is defined by the plugin registry
+loaded at server startup.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="graph.sharedneighbours">sharedNeighbours</strong></td>
 <td valign="top">[<a href="#node">Node</a>!]!</td>
-<td></td>
+<td>
+
+Nodes that are neighbours of every node in `selectedNodes`. Returns the
+intersection of each selected node's neighbour set (undirected).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">selectedNodes</td>
-<td valign="top">[<a href="#string">String</a>!]!</td>
-<td></td>
-</tr>
-<tr>
+<td valign="top">[<a href="#nodeid">NodeId</a>!]!</td>
+<td>
+
+Node ids whose common neighbours you want. Returns an empty list if `selectedNodes` is empty or any id does not exist.
+
+</td>
+</tr>
+<tr>
 <td colspan="2" valign="top"><strong id="graph.exportto">exportTo</strong></td>
 <td valign="top"><a href="#boolean">Boolean</a>!</td>
 <td>
 
-Export all nodes and edges from this graph view to another existing graph
+Copy all nodes and edges of the current graph view into another already-
+existing graph stored on the server. The destination graph is preserved
+— this only adds; it does not replace.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">path</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Destination graph path relative to the root namespace.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="graph.filter">filter</strong></td>
 <td valign="top"><a href="#graph">Graph</a>!</td>
-<td></td>
+<td>
+
+Returns a filtered view of the graph. Applies a mixed node/edge filter
+expression and narrows nodes, edges, and their properties to what matches.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">expr</td>
 <td valign="top"><a href="#graphfilter">GraphFilter</a></td>
-<td></td>
+<td>
+
+Optional composite filter combining node, edge, property, and metadata conditions. If omitted, applies the identity filter (equivalent to no filtering).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="graph.filternodes">filterNodes</strong></td>
 <td valign="top"><a href="#graph">Graph</a>!</td>
-<td></td>
+<td>
+
+Returns a graph view restricted to nodes that match the given filter; edges
+are kept only if both endpoints survive.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">expr</td>
 <td valign="top"><a href="#nodefilter">NodeFilter</a>!</td>
-<td></td>
+<td>
+
+Composite node filter (by name, property, type, etc.).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="graph.filteredges">filterEdges</strong></td>
 <td valign="top"><a href="#graph">Graph</a>!</td>
-<td></td>
+<td>
+
+Returns a graph view restricted to edges that match the given filter. Nodes
+remain in the view even if all their edges are filtered out.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">expr</td>
 <td valign="top"><a href="#edgefilter">EdgeFilter</a>!</td>
-<td></td>
+<td>
+
+Composite edge filter (by property, layer, src/dst, etc.).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="graph.getindexspec">getIndexSpec</strong></td>
@@ -2485,67 +3225,96 @@ Export all nodes and edges from this graph view to another existing graph
 <td valign="top">[<a href="#node">Node</a>!]!</td>
 <td>
 
-(Experimental) Searches for nodes which match the given filter expression.
-
-Uses Tantivy's exact search.
+(Experimental) Searches for nodes which match the given filter
+expression. Uses Tantivy's exact search; requires the graph to have
+been indexed.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">filter</td>
 <td valign="top"><a href="#nodefilter">NodeFilter</a>!</td>
-<td></td>
+<td>
+
+Composite node filter (by name, property, type, etc.).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">limit</td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Maximum number of nodes to return.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">offset</td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Number of matches to skip before returning results.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="graph.searchedges">searchEdges</strong></td>
 <td valign="top">[<a href="#edge">Edge</a>!]!</td>
 <td>
 
-(Experimental) Searches the index for edges which match the given filter expression.
-
-Uses Tantivy's exact search.
+(Experimental) Searches the index for edges which match the given
+filter expression. Uses Tantivy's exact search; requires the graph to
+have been indexed.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">filter</td>
 <td valign="top"><a href="#edgefilter">EdgeFilter</a>!</td>
-<td></td>
+<td>
+
+Composite edge filter (by property, layer, src/dst, etc.).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">limit</td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Maximum number of edges to return.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">offset</td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Number of matches to skip before returning results.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="graph.applyviews">applyViews</strong></td>
 <td valign="top"><a href="#graph">Graph</a>!</td>
 <td>
 
-Returns the specified graph view or if none is specified returns the default view.
-This allows you to specify multiple operations together.
+Apply a list of view operations in the given order and return the
+resulting graph view. Lets callers compose multiple view transforms
+(window, layer, filter, snapshot, ...) in a single call.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">views</td>
 <td valign="top">[<a href="#graphviewcollection">GraphViewCollection</a>!]!</td>
-<td></td>
+<td>
+
+Ordered list of view operations; each entry is a one-of variant applied to the running result.
+
+</td>
 </tr>
 </tbody>
 </table>
@@ -2632,6 +3401,11 @@ This allows you to specify multiple operations together.
 
 ### GraphWindowSet
 
+A lazy sequence of graph snapshots produced by `rolling` or `expanding`.
+Each entry is a `Graph` at a different window over time. Iterate via
+`list` / `page` (or count with `count`). Subsequent view ops apply
+per-window.
+
 <table>
 <thead>
 <tr>
@@ -2647,7 +3421,8 @@ This allows you to specify multiple operations together.
 <td valign="top"><a href="#int">Int</a>!</td>
 <td>
 
-Returns the number of items.
+Number of windows in this set. Materialising all windows is expensive for
+large graphs — prefer `page` over `list` when iterating.
 
 </td>
 </tr>
@@ -2667,22 +3442,39 @@ will be returned.
 <tr>
 <td colspan="2" align="right" valign="top">limit</td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Maximum number of items to return on this page.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">offset</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Extra items to skip on top of `pageIndex` paging (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">pageIndex</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Zero-based page number; multiplies `limit` to determine where to start (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="graphwindowset.list">list</strong></td>
 <td valign="top">[<a href="#graph">Graph</a>!]!</td>
-<td></td>
+<td>
+
+Materialise every window as a list. Rejected by the server when bulk list
+endpoints are disabled; use `page` for paginated access instead.
+
+</td>
 </tr>
 </tbody>
 </table>
@@ -2754,17 +3546,29 @@ will be returned.
 <tr>
 <td colspan="2" align="right" valign="top">limit</td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Maximum number of items to return on this page.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">offset</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Extra items to skip on top of `pageIndex` paging (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">pageIndex</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Zero-based page number; multiplies `limit` to determine where to start (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="history.pagerev">pageRev</strong></td>
@@ -2782,17 +3586,29 @@ will be returned.
 <tr>
 <td colspan="2" align="right" valign="top">limit</td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Maximum number of items to return on this page.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">offset</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Extra items to skip on top of `pageIndex` paging (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">pageIndex</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Zero-based page number; multiplies `limit` to determine where to start (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="history.isempty">isEmpty</strong></td>
@@ -2837,7 +3653,11 @@ Refer to chrono::format::strftime for formatting specifiers and escape sequences
 <tr>
 <td colspan="2" align="right" valign="top">formatString</td>
 <td valign="top"><a href="#string">String</a></td>
-<td></td>
+<td>
+
+Optional format string for the rendered datetime. Uses `%`-style specifiers — for example `%Y-%m-%d` for `2024-01-15`, `%Y-%m-%d %H:%M:%S` for `2024-01-15 10:30:00`, or `%H:%M` for `10:30`. Defaults to RFC 3339 (e.g. `2024-01-15T10:30:45.123+00:00`) when omitted.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="history.eventid">eventId</strong></td>
@@ -2854,7 +3674,10 @@ They are used for ordering within the same timestamp.
 <td valign="top"><a href="#intervals">Intervals</a>!</td>
 <td>
 
-Returns an Intervals object which calculates the intervals between consecutive EventTime timestamps.
+Inter-event gap analysis for this history. The returned `Intervals`
+object exposes each gap (in milliseconds) between consecutive events,
+plus summary statistics — `min` / `max` / `mean` / `median` — and
+paginated access via `list` / `listRev` / `page` / `pageRev`.
 
 </td>
 </tr>
@@ -2889,7 +3712,11 @@ will be raised on time conversion error. Defaults to False.
 <tr>
 <td colspan="2" align="right" valign="top">filterBroken</td>
 <td valign="top"><a href="#boolean">Boolean</a></td>
-<td></td>
+<td>
+
+If true, ignore unconvertible timestamps; if false, raise an error on the first conversion failure. Defaults to false.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="historydatetime.listrev">listRev</strong></td>
@@ -2905,7 +3732,11 @@ will be raised on time conversion error. Defaults to False.
 <tr>
 <td colspan="2" align="right" valign="top">filterBroken</td>
 <td valign="top"><a href="#boolean">Boolean</a></td>
-<td></td>
+<td>
+
+If true, ignore unconvertible timestamps; if false, raise an error on the first conversion failure. Defaults to false.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="historydatetime.page">page</strong></td>
@@ -2925,22 +3756,38 @@ will be returned.
 <tr>
 <td colspan="2" align="right" valign="top">limit</td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Maximum number of items to return on this page.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">offset</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Extra items to skip on top of `pageIndex` paging (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">pageIndex</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Zero-based page number; multiplies `limit` to determine where to start (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">filterBroken</td>
 <td valign="top"><a href="#boolean">Boolean</a></td>
-<td></td>
+<td>
+
+If true, skip timestamps whose conversion fails; if false, raise an error on the first conversion failure. Defaults to false.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="historydatetime.pagerev">pageRev</strong></td>
@@ -2960,22 +3807,38 @@ will be returned.
 <tr>
 <td colspan="2" align="right" valign="top">limit</td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Maximum number of items to return on this page.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">offset</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Extra items to skip on top of `pageIndex` paging (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">pageIndex</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Zero-based page number; multiplies `limit` to determine where to start (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">filterBroken</td>
 <td valign="top"><a href="#boolean">Boolean</a></td>
-<td></td>
+<td>
+
+If true, skip timestamps whose conversion fails; if false, raise an error on the first conversion failure. Defaults to false.
+
+</td>
 </tr>
 </tbody>
 </table>
@@ -3028,17 +3891,29 @@ will be returned.
 <tr>
 <td colspan="2" align="right" valign="top">limit</td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Maximum number of items to return on this page.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">offset</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Extra items to skip on top of `pageIndex` paging (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">pageIndex</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Zero-based page number; multiplies `limit` to determine where to start (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="historyeventid.pagerev">pageRev</strong></td>
@@ -3056,17 +3931,29 @@ will be returned.
 <tr>
 <td colspan="2" align="right" valign="top">limit</td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Maximum number of items to return on this page.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">offset</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Extra items to skip on top of `pageIndex` paging (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">pageIndex</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Zero-based page number; multiplies `limit` to determine where to start (default 0).
+
+</td>
 </tr>
 </tbody>
 </table>
@@ -3119,17 +4006,29 @@ will be returned.
 <tr>
 <td colspan="2" align="right" valign="top">limit</td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Maximum number of items to return on this page.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">offset</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Extra items to skip on top of `pageIndex` paging (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">pageIndex</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Zero-based page number; multiplies `limit` to determine where to start (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="historytimestamp.pagerev">pageRev</strong></td>
@@ -3147,17 +4046,29 @@ will be returned.
 <tr>
 <td colspan="2" align="right" valign="top">limit</td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Maximum number of items to return on this page.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">offset</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Extra items to skip on top of `pageIndex` paging (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">pageIndex</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Zero-based page number; multiplies `limit` to determine where to start (default 0).
+
+</td>
 </tr>
 </tbody>
 </table>
@@ -3261,18 +4172,30 @@ will be returned.
 <tr>
 <td colspan="2" align="right" valign="top">limit</td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Maximum number of items to return on this page.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">offset</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Extra items to skip on top of `pageIndex` paging (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">pageIndex</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
-</tr>
+<td>
+
+Zero-based page number; multiplies `limit` to determine where to start (default 0).
+
+</td>
+</tr>
 <tr>
 <td colspan="2" valign="top"><strong id="intervals.pagerev">pageRev</strong></td>
 <td valign="top">[<a href="#int">Int</a>!]!</td>
@@ -3289,17 +4212,29 @@ will be returned.
 <tr>
 <td colspan="2" align="right" valign="top">limit</td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Maximum number of items to return on this page.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">offset</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Extra items to skip on top of `pageIndex` paging (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">pageIndex</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Zero-based page number; multiplies `limit` to determine where to start (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="intervals.mean">mean</strong></td>
@@ -3342,6 +4277,9 @@ Compute the minimum interval between consecutive timestamps. Returns None if few
 
 ### LayerSchema
 
+Describes a single edge layer — its name and the per `(srcType, dstType)`
+edge schemas observed within it.
+
 <table>
 <thead>
 <tr>
@@ -3375,6 +4313,11 @@ Returns the list of edge schemas for this edge layer
 
 ### MetaGraph
 
+Lightweight summary of a stored graph — its name, path, counts, and
+filesystem timestamps — served without deserializing the full graph.
+Useful for listing what's available on the server before committing to a
+full load.
+
 <table>
 <thead>
 <tr>
@@ -3465,6 +4408,11 @@ Returns the metadata of the graph.
 
 ### Metadata
 
+Constant key/value metadata attached to an entity (node, edge, or graph).
+Metadata has no timeline — each key maps to exactly one value for the
+lifetime of the entity. Separate from `Properties`, which carries
+time-varying data.
+
 <table>
 <thead>
 <tr>
@@ -3480,35 +4428,44 @@ Returns the metadata of the graph.
 <td valign="top"><a href="#property">Property</a></td>
 <td>
 
-Get metadata value matching the specified key.
+Look up a single metadata value by key. Returns null if no metadata with that
+key exists.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">key</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+The metadata name.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="metadata.contains">contains</strong></td>
 <td valign="top"><a href="#boolean">Boolean</a>!</td>
 <td>
 
-/// Check if the key is in the metadata.
+Returns true if a metadata entry with the given key exists.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">key</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+The metadata name to look up.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="metadata.keys">keys</strong></td>
 <td valign="top">[<a href="#string">String</a>!]!</td>
 <td>
 
-Return all metadata keys.
+All metadata keys present on this entity.
 
 </td>
 </tr>
@@ -3517,20 +4474,28 @@ Return all metadata keys.
 <td valign="top">[<a href="#property">Property</a>!]!</td>
 <td>
 
-/// Return all metadata values.
+All metadata values as `{key, value}` entries.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">keys</td>
 <td valign="top">[<a href="#string">String</a>!]</td>
-<td></td>
+<td>
+
+Optional whitelist. If provided, only metadata with these keys is returned; if omitted, every metadata entry is returned.
+
+</td>
 </tr>
 </tbody>
 </table>
 
 ### MutableEdge
 
+Write-side handle for a single edge — returned from `addEdge` or
+`MutableGraph.edge`. Supports adding updates, deletions, and attaching
+or updating metadata.
+
 <table>
 <thead>
 <tr>
@@ -3582,96 +4547,137 @@ Get the mutable destination node of the edge.
 <td valign="top"><a href="#boolean">Boolean</a>!</td>
 <td>
 
-Mark the edge as deleted at time time.
+Mark this edge as deleted at the given time. Persistent graphs treat this
+as a tombstone (the edge becomes invalid from `time` onwards); event
+graphs simply log the deletion event.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">time</td>
-<td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td valign="top"><a href="#timeinput">TimeInput</a>!</td>
+<td>
+
+Time of the deletion.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">layer</td>
 <td valign="top"><a href="#string">String</a></td>
-<td></td>
+<td>
+
+Optional layer name. If omitted, uses the layer the edge was originally added on (when called after `addEdge`).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="mutableedge.addmetadata">addMetadata</strong></td>
 <td valign="top"><a href="#boolean">Boolean</a>!</td>
 <td>
 
-Add metadata to the edge (errors if the value already exists).
-
-If this is called after add_edge, the layer is inherited from the add_edge and does not
-need to be specified again.
+Add metadata to this edge. Errors if any of the keys already exists —
+use `updateMetadata` to overwrite. If this is called after `addEdge`,
+the layer is inherited and does not need to be specified again.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">properties</td>
 <td valign="top">[<a href="#propertyinput">PropertyInput</a>!]!</td>
-<td></td>
+<td>
+
+List of `{key, value}` pairs to set as metadata.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">layer</td>
 <td valign="top"><a href="#string">String</a></td>
-<td></td>
+<td>
+
+Optional layer name; defaults to the inherited layer.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="mutableedge.updatemetadata">updateMetadata</strong></td>
 <td valign="top"><a href="#boolean">Boolean</a>!</td>
 <td>
 
-Update metadata of the edge (existing values are overwritten).
-
-If this is called after add_edge, the layer is inherited from the add_edge and does not
-need to be specified again.
+Update metadata of this edge, overwriting any existing values for the
+given keys. If this is called after `addEdge`, the layer is inherited
+and does not need to be specified again.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">properties</td>
 <td valign="top">[<a href="#propertyinput">PropertyInput</a>!]!</td>
-<td></td>
+<td>
+
+List of `{key, value}` pairs to upsert.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">layer</td>
 <td valign="top"><a href="#string">String</a></td>
-<td></td>
+<td>
+
+Optional layer name; defaults to the inherited layer.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="mutableedge.addupdates">addUpdates</strong></td>
 <td valign="top"><a href="#boolean">Boolean</a>!</td>
 <td>
 
-Add temporal property updates to the edge.
-
-If this is called after add_edge, the layer is inherited from the add_edge and does not
-need to be specified again.
+Append a property update to this edge at a specific time. If called
+after `addEdge`, the layer is inherited and does not need to be
+specified again.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">time</td>
-<td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td valign="top"><a href="#timeinput">TimeInput</a>!</td>
+<td>
+
+Time of the update.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">properties</td>
 <td valign="top">[<a href="#propertyinput">PropertyInput</a>!]</td>
-<td></td>
+<td>
+
+Optional `{key, value}` pairs attached to the event.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">layer</td>
 <td valign="top"><a href="#string">String</a></td>
-<td></td>
+<td>
+
+Optional layer name; defaults to the inherited layer.
+
+</td>
 </tr>
 </tbody>
 </table>
 
 ### MutableGraph
 
+Write-enabled handle for a graph. Obtained by calling `updateGraph(path)`
+on the root query with a path you have write permission for. Supports
+adding nodes and edges (individually or in batches), attaching
+properties/metadata, and looking up mutable `node`/`edge` handles. Use the
+read-only `graph(path)` resolver for queries.
+
 <table>
 <thead>
 <tr>
@@ -3687,7 +4693,20 @@ need to be specified again.
 <td valign="top"><a href="#graph">Graph</a>!</td>
 <td>
 
-Get the non-mutable graph.
+Read-only view of this graph — identical to what you'd get from
+`graph(path:)` on the query root. Use this when you want to compose
+queries on the graph you've just mutated. `graphType` lets you
+re-interpret the graph at query time (see `graph(path:)` for
+semantics); defaults to the stored graph's native type.
+
+</td>
+</tr>
+<tr>
+<td colspan="2" align="right" valign="top">graphType</td>
+<td valign="top"><a href="#graphtype">GraphType</a></td>
+<td>
+
+Optional override for graph semantics — `EVENT` treats every update as a point-in-time event, `PERSISTENT` carries values forward until overwritten or deleted. Defaults to the stored graph's native type.
 
 </td>
 </tr>
@@ -3696,235 +4715,378 @@ Get the non-mutable graph.
 <td valign="top"><a href="#mutablenode">MutableNode</a></td>
 <td>
 
-Get mutable existing node.
+Look up an existing node for mutation. Returns null if the node doesn't
+exist; use `addNode` or `createNode` to create one.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">name</td>
-<td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td valign="top"><a href="#nodeid">NodeId</a>!</td>
+<td>
+
+Node id.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="mutablegraph.addnode">addNode</strong></td>
 <td valign="top"><a href="#mutablenode">MutableNode</a>!</td>
 <td>
 
-Add a new node or add updates to an existing node.
+Add a new node or append an update to an existing one. Upsert semantics:
+no error if the node already exists — properties and type are merged.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">time</td>
-<td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td valign="top"><a href="#timeinput">TimeInput</a>!</td>
+<td>
+
+Time of the event.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">name</td>
-<td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td valign="top"><a href="#nodeid">NodeId</a>!</td>
+<td>
+
+Node id.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">properties</td>
 <td valign="top">[<a href="#propertyinput">PropertyInput</a>!]</td>
-<td></td>
+<td>
+
+Optional property updates attached to this event.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">nodeType</td>
 <td valign="top"><a href="#string">String</a></td>
-<td></td>
+<td>
+
+Optional node type to assign. If provided, sets the node's type at this event.
+
+</td>
+</tr>
+<tr>
+<td colspan="2" align="right" valign="top">layer</td>
+<td valign="top"><a href="#string">String</a></td>
+<td>
+
+Optional layer name. If omitted, the default layer is used.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="mutablegraph.createnode">createNode</strong></td>
 <td valign="top"><a href="#mutablenode">MutableNode</a>!</td>
 <td>
 
-Create a new node or fail if it already exists.
+Create a new node or fail if it already exists. Strict alternative to
+`addNode` — use this when you want to detect collisions.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">time</td>
-<td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td valign="top"><a href="#timeinput">TimeInput</a>!</td>
+<td>
+
+Time of the create event.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">name</td>
-<td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td valign="top"><a href="#nodeid">NodeId</a>!</td>
+<td>
+
+Node id.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">properties</td>
 <td valign="top">[<a href="#propertyinput">PropertyInput</a>!]</td>
-<td></td>
+<td>
+
+Optional property updates attached to this event.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">nodeType</td>
 <td valign="top"><a href="#string">String</a></td>
-<td></td>
+<td>
+
+Optional node type to assign. If provided, sets the node's type at this event.
+
+</td>
+</tr>
+<tr>
+<td colspan="2" align="right" valign="top">layer</td>
+<td valign="top"><a href="#string">String</a></td>
+<td>
+
+Optional layer name. If omitted, the default layer is used.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="mutablegraph.addnodes">addNodes</strong></td>
 <td valign="top"><a href="#boolean">Boolean</a>!</td>
 <td>
 
-Add a batch of nodes.
+Batch-add multiple nodes in one call. For each `NodeAddition`, applies every
+update it carries (time/properties pairs), then optionally sets its node type
+and adds any metadata. On partial failure, returns a `BatchFailures` error
+describing which entries failed and why; otherwise returns true.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">nodes</td>
 <td valign="top">[<a href="#nodeaddition">NodeAddition</a>!]!</td>
-<td></td>
+<td>
+
+List of `NodeAddition` inputs, each specifying a node's name, optional type, layer, per-timestamp updates, and metadata.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="mutablegraph.edge">edge</strong></td>
 <td valign="top"><a href="#mutableedge">MutableEdge</a></td>
 <td>
 
-Get a mutable existing edge.
+Look up an existing edge for mutation. Returns null if no such edge exists.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">src</td>
-<td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td valign="top"><a href="#nodeid">NodeId</a>!</td>
+<td>
+
+Source node id.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">dst</td>
-<td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td valign="top"><a href="#nodeid">NodeId</a>!</td>
+<td>
+
+Destination node id.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="mutablegraph.addedge">addEdge</strong></td>
 <td valign="top"><a href="#mutableedge">MutableEdge</a>!</td>
 <td>
 
-Add a new edge or add updates to an existing edge.
+Add a new edge or append an update to an existing one. Upsert semantics:
+safe to call on an edge that already exists — creates missing endpoints if
+needed.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">time</td>
-<td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td valign="top"><a href="#timeinput">TimeInput</a>!</td>
+<td>
+
+Time of the event.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">src</td>
-<td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td valign="top"><a href="#nodeid">NodeId</a>!</td>
+<td>
+
+Source node id.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">dst</td>
-<td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td valign="top"><a href="#nodeid">NodeId</a>!</td>
+<td>
+
+Destination node id.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">properties</td>
 <td valign="top">[<a href="#propertyinput">PropertyInput</a>!]</td>
-<td></td>
+<td>
+
+Optional property updates attached to this event.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">layer</td>
 <td valign="top"><a href="#string">String</a></td>
-<td></td>
+<td>
+
+Optional layer name. If omitted, the default layer is used.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="mutablegraph.addedges">addEdges</strong></td>
 <td valign="top"><a href="#boolean">Boolean</a>!</td>
 <td>
 
-Add a batch of edges.
+Batch-add multiple edges in one call. For each `EdgeAddition`, applies every
+update it carries, then adds any metadata. On partial failure, returns a
+`BatchFailures` error describing which entries failed; otherwise returns
+true.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">edges</td>
 <td valign="top">[<a href="#edgeaddition">EdgeAddition</a>!]!</td>
-<td></td>
+<td>
+
+List of `EdgeAddition` inputs, each specifying an edge's `src`, `dst`, optional layer, per-timestamp updates, and metadata.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="mutablegraph.deleteedge">deleteEdge</strong></td>
 <td valign="top"><a href="#mutableedge">MutableEdge</a>!</td>
 <td>
 
-Mark an edge as deleted (creates the edge if it did not exist).
+Mark an edge as deleted at the given time. Persistent graphs treat this
+as a tombstone (the edge becomes invalid from `time` onwards); event
+graphs simply log the deletion event. Creates the edge first if it did
+not exist.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">time</td>
-<td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td valign="top"><a href="#timeinput">TimeInput</a>!</td>
+<td>
+
+Time of the deletion.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">src</td>
-<td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td valign="top"><a href="#nodeid">NodeId</a>!</td>
+<td>
+
+Source node id.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">dst</td>
-<td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td valign="top"><a href="#nodeid">NodeId</a>!</td>
+<td>
+
+Destination node id.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">layer</td>
 <td valign="top"><a href="#string">String</a></td>
-<td></td>
+<td>
+
+Optional layer name. If omitted, the default layer is used.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="mutablegraph.addproperties">addProperties</strong></td>
 <td valign="top"><a href="#boolean">Boolean</a>!</td>
 <td>
 
-Add temporal properties to graph.
+Add temporal properties to the graph itself (not a node or edge). Each
+call records a property update at `t`.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">t</td>
-<td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td valign="top"><a href="#timeinput">TimeInput</a>!</td>
+<td>
+
+Time of the update.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">properties</td>
 <td valign="top">[<a href="#propertyinput">PropertyInput</a>!]!</td>
-<td></td>
+<td>
+
+List of `{key, value}` pairs to set.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="mutablegraph.addmetadata">addMetadata</strong></td>
 <td valign="top"><a href="#boolean">Boolean</a>!</td>
 <td>
 
-Add metadata to graph (errors if the property already exists).
+Add metadata to the graph itself. Errors if any of the keys already
+exists — use `updateMetadata` to overwrite.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">properties</td>
 <td valign="top">[<a href="#propertyinput">PropertyInput</a>!]!</td>
-<td></td>
+<td>
+
+List of `{key, value}` pairs to set as metadata.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="mutablegraph.updatemetadata">updateMetadata</strong></td>
 <td valign="top"><a href="#boolean">Boolean</a>!</td>
 <td>
 
-Update metadata of the graph (overwrites existing values).
+Update metadata of the graph itself, overwriting any existing values for
+the given keys.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">properties</td>
 <td valign="top">[<a href="#propertyinput">PropertyInput</a>!]!</td>
-<td></td>
+<td>
+
+List of `{key, value}` pairs to upsert.
+
+</td>
 </tr>
 </tbody>
 </table>
 
 ### MutableNode
 
+Write-side handle for a single node — returned from `addNode`, `createNode`,
+or `MutableGraph.node`. Supports adding updates, setting node type, and
+attaching or updating metadata.
+
 <table>
 <thead>
 <tr>
@@ -3958,61 +5120,93 @@ Get the non-mutable Node.
 <td valign="top"><a href="#boolean">Boolean</a>!</td>
 <td>
 
-Add metadata to the node (errors if the property already exists).
+Add metadata to this node. Errors if any of the keys already exists —
+use `updateMetadata` to overwrite.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">properties</td>
 <td valign="top">[<a href="#propertyinput">PropertyInput</a>!]!</td>
-<td></td>
+<td>
+
+List of `{key, value}` pairs to set as metadata.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="mutablenode.setnodetype">setNodeType</strong></td>
 <td valign="top"><a href="#boolean">Boolean</a>!</td>
 <td>
 
-Set the node type (errors if the node already has a non-default type).
+Set this node's type. Errors if the node already has a non-default
+type and you're trying to change it.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">newType</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Node-type name to assign.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="mutablenode.updatemetadata">updateMetadata</strong></td>
 <td valign="top"><a href="#boolean">Boolean</a>!</td>
 <td>
 
-Update metadata of the node (overwrites existing property values).
+Update metadata of this node, overwriting any existing values for the
+given keys.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">properties</td>
 <td valign="top">[<a href="#propertyinput">PropertyInput</a>!]!</td>
-<td></td>
+<td>
+
+List of `{key, value}` pairs to upsert.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="mutablenode.addupdates">addUpdates</strong></td>
 <td valign="top"><a href="#boolean">Boolean</a>!</td>
 <td>
 
-Add temporal property updates to the node.
+Append a property update to this node at a specific time.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">time</td>
-<td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td valign="top"><a href="#timeinput">TimeInput</a>!</td>
+<td>
+
+Time of the update.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">properties</td>
 <td valign="top">[<a href="#propertyinput">PropertyInput</a>!]</td>
-<td></td>
+<td>
+
+Optional `{key, value}` pairs attached to the event.
+
+</td>
+</tr>
+<tr>
+<td colspan="2" align="right" valign="top">layer</td>
+<td valign="top"><a href="#string">String</a></td>
+<td>
+
+Optional layer name. If omitted, the default layer is used.
+
+</td>
 </tr>
 </tbody>
 </table>
@@ -4039,6 +5233,11 @@ Add temporal property updates to the node.
 
 ### Namespace
 
+A directory-like container for graphs and nested namespaces. Graphs are
+addressed by path (e.g. `"team/project/graph"`), and every segment except
+the last is a namespace. Use to browse what's stored on the server without
+loading any graph data.
+
 <table>
 <thead>
 <tr>
@@ -4052,27 +5251,53 @@ Add temporal property updates to the node.
 <tr>
 <td colspan="2" valign="top"><strong id="namespace.graphs">graphs</strong></td>
 <td valign="top"><a href="#collectionofmetagraph">CollectionOfMetaGraph</a>!</td>
-<td></td>
+<td>
+
+Graphs directly inside this namespace (excludes graphs in nested
+namespaces). Filtered by the caller's permissions — only graphs the
+caller is allowed to see are returned.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="namespace.path">path</strong></td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Path of this namespace relative to the root namespace. Empty string for
+the root namespace itself.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="namespace.parent">parent</strong></td>
 <td valign="top"><a href="#namespace">Namespace</a></td>
-<td></td>
+<td>
+
+Parent namespace, or null at the root.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="namespace.children">children</strong></td>
 <td valign="top"><a href="#collectionofnamespace">CollectionOfNamespace</a>!</td>
-<td></td>
+<td>
+
+Sub-namespaces directly inside this one (one level down, not recursive).
+Filtered by permissions.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="namespace.items">items</strong></td>
 <td valign="top"><a href="#collectionofnamespaceditem">CollectionOfNamespacedItem</a>!</td>
-<td></td>
+<td>
+
+Everything in this namespace — sub-namespaces and graphs — as a single
+heterogeneous collection. Sub-namespaces are listed before graphs.
+Filtered by permissions.
+
+</td>
 </tr>
 </tbody>
 </table>
@@ -4093,10 +5318,11 @@ Raphtory graph node.
 <tbody>
 <tr>
 <td colspan="2" valign="top"><strong id="node.id">id</strong></td>
-<td valign="top"><a href="#string">String</a>!</td>
+<td valign="top"><a href="#nodeid">NodeId</a>!</td>
 <td>
 
-Returns the unique id of the node.
+Returns the unique id of the node — `String` for string-indexed
+graphs, non-negative `Int` for integer-indexed graphs.
 
 </td>
 </tr>
@@ -4130,7 +5356,11 @@ Return a view of node containing all layers specified.
 <tr>
 <td colspan="2" align="right" valign="top">names</td>
 <td valign="top">[<a href="#string">String</a>!]!</td>
-<td></td>
+<td>
+
+Layer names to include.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="node.excludelayers">excludeLayers</strong></td>
@@ -4144,7 +5374,11 @@ Returns a collection containing nodes belonging to all layers except the exclude
 <tr>
 <td colspan="2" align="right" valign="top">names</td>
 <td valign="top">[<a href="#string">String</a>!]!</td>
-<td></td>
+<td>
+
+Layer names to exclude.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="node.layer">layer</strong></td>
@@ -4158,7 +5392,11 @@ Returns a collection containing nodes belonging to the specified layer.
 <tr>
 <td colspan="2" align="right" valign="top">name</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Layer name to include.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="node.excludelayer">excludeLayer</strong></td>
@@ -4172,7 +5410,11 @@ Returns a collection containing nodes belonging to all layers except the exclude
 <tr>
 <td colspan="2" align="right" valign="top">name</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Layer name to exclude.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="node.rolling">rolling</strong></td>
@@ -4194,17 +5436,29 @@ the start of the first window and/or after the end of the last window (i.e. not
 <tr>
 <td colspan="2" align="right" valign="top">window</td>
 <td valign="top"><a href="#windowduration">WindowDuration</a>!</td>
-<td></td>
+<td>
+
+Width of each window. Pass either `{epoch: <ms>}` for a discrete number of milliseconds (e.g. `{epoch: 1000}` for 1 second), or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}` or `{duration: 2 hours and 30 minutes}`).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">step</td>
 <td valign="top"><a href="#windowduration">WindowDuration</a></td>
-<td></td>
+<td>
+
+Optional gap between the start of one window and the start of the next. Accepts the same `{epoch: <ms>}` or `{duration: <text>}` values as `window`. Defaults to `window` — i.e. windows touch end-to-end with no overlap and no gap.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">alignmentUnit</td>
 <td valign="top"><a href="#alignmentunit">AlignmentUnit</a></td>
-<td></td>
+<td>
+
+Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step` (or `window` if no step is set).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="node.expanding">expanding</strong></td>
@@ -4224,12 +5478,20 @@ e.g. "1 month and 1 day" will align at the start of the day.
 <tr>
 <td colspan="2" align="right" valign="top">step</td>
 <td valign="top"><a href="#windowduration">WindowDuration</a>!</td>
-<td></td>
+<td>
+
+How much the window grows by on each step. Pass either `{epoch: <ms>}` for a discrete number of milliseconds, or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}`).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">alignmentUnit</td>
 <td valign="top"><a href="#alignmentunit">AlignmentUnit</a></td>
-<td></td>
+<td>
+
+Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step`.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="node.window">window</strong></td>
@@ -4243,12 +5505,20 @@ Create a view of the node including all events between the specified start (incl
 <tr>
 <td colspan="2" align="right" valign="top">start</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Inclusive lower bound.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">end</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Exclusive upper bound.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="node.at">at</strong></td>
@@ -4262,7 +5532,11 @@ Create a view of the node including all events at a specified time.
 <tr>
 <td colspan="2" align="right" valign="top">time</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Instant to pin the view to.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="node.latest">latest</strong></td>
@@ -4285,7 +5559,11 @@ Create a view of the node including all events that are valid at the specified t
 <tr>
 <td colspan="2" align="right" valign="top">time</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Instant at which entities must be valid.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="node.snapshotlatest">snapshotLatest</strong></td>
@@ -4308,7 +5586,11 @@ Create a view of the node including all events before specified end time (exclus
 <tr>
 <td colspan="2" align="right" valign="top">time</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Exclusive upper bound.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="node.after">after</strong></td>
@@ -4322,7 +5604,11 @@ Create a view of the node including all events after the specified start time (e
 <tr>
 <td colspan="2" align="right" valign="top">time</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Exclusive lower bound.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="node.shrinkwindow">shrinkWindow</strong></td>
@@ -4336,12 +5622,20 @@ Shrink a Window to a specified start and end time, if these are earlier and late
 <tr>
 <td colspan="2" align="right" valign="top">start</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Proposed new start (TimeInput); ignored if it would widen the window.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">end</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Proposed new end (TimeInput); ignored if it would widen the window.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="node.shrinkstart">shrinkStart</strong></td>
@@ -4355,7 +5649,11 @@ Set the start of the window to the larger of a specified start time and self.sta
 <tr>
 <td colspan="2" align="right" valign="top">start</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Proposed new start (TimeInput); ignored if it would widen the window.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="node.shrinkend">shrinkEnd</strong></td>
@@ -4369,7 +5667,11 @@ Set the end of the window to the smaller of a specified end and self.end().
 <tr>
 <td colspan="2" align="right" valign="top">end</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Proposed new end (TimeInput); ignored if it would widen the window.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="node.applyviews">applyViews</strong></td>
@@ -4625,6 +5927,10 @@ Returns the number of neighbours that have at least one out-going edge from this
 
 ### NodeSchema
 
+Describes nodes of a specific type in a graph — its property keys and
+observed value types (and, for string-valued properties, the set of
+distinct values seen). One `NodeSchema` per node type.
+
 <table>
 <thead>
 <tr>
@@ -4638,27 +5944,43 @@ Returns the number of neighbours that have at least one out-going edge from this
 <tr>
 <td colspan="2" valign="top"><strong id="nodeschema.typename">typeName</strong></td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+The node type this schema describes (e.g. `"person"`, `"org"`).
+Falls back to the default node type for untyped nodes.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="nodeschema.properties">properties</strong></td>
 <td valign="top">[<a href="#propertyschema">PropertySchema</a>!]!</td>
 <td>
 
-Returns the list of property schemas for this node
+Property schemas seen on nodes of this type — one entry per property key
+ever set on a node of this type, with its observed `PropertyType` and (for
+string-valued properties) the set of distinct values.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="nodeschema.metadata">metadata</strong></td>
 <td valign="top">[<a href="#propertyschema">PropertySchema</a>!]!</td>
-<td></td>
+<td>
+
+Metadata schemas seen on nodes of this type — like `properties`, but
+covering metadata fields rather than temporal properties.
+
+</td>
 </tr>
 </tbody>
 </table>
 
 ### NodeWindowSet
 
+A lazy sequence of per-window views of a single node, produced by
+`node.rolling` / `node.expanding`. Each entry is the node as it exists in
+that window.
+
 <table>
 <thead>
 <tr>
@@ -4672,7 +5994,12 @@ Returns the list of property schemas for this node
 <tr>
 <td colspan="2" valign="top"><strong id="nodewindowset.count">count</strong></td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Number of windows in this set. Materialising all windows is expensive for
+large graphs — prefer `page` over `list` when iterating.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="nodewindowset.page">page</strong></td>
@@ -4690,28 +6017,49 @@ will be returned.
 <tr>
 <td colspan="2" align="right" valign="top">limit</td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Maximum number of items to return on this page.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">offset</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Extra items to skip on top of `pageIndex` paging (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">pageIndex</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Zero-based page number; multiplies `limit` to determine where to start (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="nodewindowset.list">list</strong></td>
 <td valign="top">[<a href="#node">Node</a>!]!</td>
-<td></td>
+<td>
+
+Materialise every window as a list. Rejected by the server when bulk list
+endpoints are disabled; use `page` for paginated access instead.
+
+</td>
 </tr>
 </tbody>
 </table>
 
 ### Nodes
 
+A lazy collection of nodes from a graph view. Supports all the same view
+transforms as `Graph` (window, layer, filter, ...) plus pagination and
+sorting. Iterated via `list` / `page` / `ids` / `count`.
+
 <table>
 <thead>
 <tr>
@@ -4743,7 +6091,11 @@ Return a view of the nodes containing all layers specified.
 <tr>
 <td colspan="2" align="right" valign="top">names</td>
 <td valign="top">[<a href="#string">String</a>!]!</td>
-<td></td>
+<td>
+
+Layer names to include.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="nodes.excludelayers">excludeLayers</strong></td>
@@ -4757,7 +6109,11 @@ Return a view of the nodes containing all layers except those specified.
 <tr>
 <td colspan="2" align="right" valign="top">names</td>
 <td valign="top">[<a href="#string">String</a>!]!</td>
-<td></td>
+<td>
+
+Layer names to exclude.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="nodes.layer">layer</strong></td>
@@ -4771,7 +6127,11 @@ Return a view of the nodes containing the specified layer.
 <tr>
 <td colspan="2" align="right" valign="top">name</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Layer name to include.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="nodes.excludelayer">excludeLayer</strong></td>
@@ -4785,7 +6145,11 @@ Return a view of the nodes containing all layers except those specified.
 <tr>
 <td colspan="2" align="right" valign="top">name</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Layer name to exclude.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="nodes.rolling">rolling</strong></td>
@@ -4807,17 +6171,29 @@ the start of the first window and/or after the end of the last window (i.e. not
 <tr>
 <td colspan="2" align="right" valign="top">window</td>
 <td valign="top"><a href="#windowduration">WindowDuration</a>!</td>
-<td></td>
+<td>
+
+Width of each window. Pass either `{epoch: <ms>}` for a discrete number of milliseconds (e.g. `{epoch: 1000}` for 1 second), or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}` or `{duration: 2 hours and 30 minutes}`).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">step</td>
 <td valign="top"><a href="#windowduration">WindowDuration</a></td>
-<td></td>
+<td>
+
+Optional gap between the start of one window and the start of the next. Accepts the same `{epoch: <ms>}` or `{duration: <text>}` values as `window`. Defaults to `window` — i.e. windows touch end-to-end with no overlap and no gap.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">alignmentUnit</td>
 <td valign="top"><a href="#alignmentunit">AlignmentUnit</a></td>
-<td></td>
+<td>
+
+Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step` (or `window` if no step is set).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="nodes.expanding">expanding</strong></td>
@@ -4837,12 +6213,20 @@ e.g. "1 month and 1 day" will align at the start of the day.
 <tr>
 <td colspan="2" align="right" valign="top">step</td>
 <td valign="top"><a href="#windowduration">WindowDuration</a>!</td>
-<td></td>
+<td>
+
+How much the window grows by on each step. Pass either `{epoch: <ms>}` for a discrete number of milliseconds, or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}`).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">alignmentUnit</td>
 <td valign="top"><a href="#alignmentunit">AlignmentUnit</a></td>
-<td></td>
+<td>
+
+Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step`.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="nodes.window">window</strong></td>
@@ -4856,12 +6240,20 @@ Create a view of the node including all events between the specified start (incl
 <tr>
 <td colspan="2" align="right" valign="top">start</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Inclusive lower bound.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">end</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Exclusive upper bound.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="nodes.at">at</strong></td>
@@ -4875,7 +6267,11 @@ Create a view of the nodes including all events at a specified time.
 <tr>
 <td colspan="2" align="right" valign="top">time</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Instant to pin the view to.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="nodes.latest">latest</strong></td>
@@ -4898,7 +6294,11 @@ Create a view of the nodes including all events that are valid at the specified
 <tr>
 <td colspan="2" align="right" valign="top">time</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Instant at which entities must be valid.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="nodes.snapshotlatest">snapshotLatest</strong></td>
@@ -4921,7 +6321,11 @@ Create a view of the nodes including all events before specified end time (exclu
 <tr>
 <td colspan="2" align="right" valign="top">time</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Exclusive upper bound.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="nodes.after">after</strong></td>
@@ -4935,7 +6339,11 @@ Create a view of the nodes including all events after the specified start time (
 <tr>
 <td colspan="2" align="right" valign="top">time</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Exclusive lower bound.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="nodes.shrinkwindow">shrinkWindow</strong></td>
@@ -4949,12 +6357,20 @@ Shrink both the start and end of the window.
 <tr>
 <td colspan="2" align="right" valign="top">start</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Proposed new start (TimeInput); ignored if it would widen the window.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">end</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Proposed new end (TimeInput); ignored if it would widen the window.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="nodes.shrinkstart">shrinkStart</strong></td>
@@ -4968,7 +6384,11 @@ Set the start of the window to the larger of a specified start time and self.sta
 <tr>
 <td colspan="2" align="right" valign="top">start</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Proposed new start (TimeInput); ignored if it would widen the window.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="nodes.shrinkend">shrinkEnd</strong></td>
@@ -4982,7 +6402,11 @@ Set the end of the window to the smaller of a specified end and self.end().
 <tr>
 <td colspan="2" align="right" valign="top">end</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Proposed new end (TimeInput); ignored if it would widen the window.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="nodes.typefilter">typeFilter</strong></td>
@@ -4996,27 +6420,50 @@ Filter nodes by node type.
 <tr>
 <td colspan="2" align="right" valign="top">nodeTypes</td>
 <td valign="top">[<a href="#string">String</a>!]!</td>
-<td></td>
+<td>
+
+Node-type names to keep.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="nodes.applyviews">applyViews</strong></td>
 <td valign="top"><a href="#nodes">Nodes</a>!</td>
-<td></td>
+<td>
+
+Apply a list of views in the given order and return the resulting nodes
+collection. Lets callers compose window, layer, filter, and snapshot
+operations in a single call.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">views</td>
 <td valign="top">[<a href="#nodesviewcollection">NodesViewCollection</a>!]!</td>
-<td></td>
+<td>
+
+Ordered list of view operations; each entry is a one-of variant (`window`, `layer`, `filter`, etc.) applied to the running result.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="nodes.sorted">sorted</strong></td>
 <td valign="top"><a href="#nodes">Nodes</a>!</td>
-<td></td>
+<td>
+
+Sort the nodes. Multiple criteria are applied lexicographically (ties on the
+first key break to the second, etc.).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">sortBys</td>
 <td valign="top">[<a href="#nodesortby">NodeSortBy</a>!]!</td>
-<td></td>
+<td>
+
+Ordered list of sort keys. Each entry chooses exactly one of `id` / `time` / `property`, with an optional `reverse: true` to flip order.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="nodes.start">start</strong></td>
@@ -5039,7 +6486,11 @@ Returns the end time of the window. Errors if there is no window.
 <tr>
 <td colspan="2" valign="top"><strong id="nodes.count">count</strong></td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Number of nodes in the current view.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="nodes.page">page</strong></td>
@@ -5057,29 +6508,47 @@ will be returned.
 <tr>
 <td colspan="2" align="right" valign="top">limit</td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Maximum number of items to return on this page.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">offset</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Extra items to skip on top of `pageIndex` paging (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">pageIndex</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Zero-based page number; multiplies `limit` to determine where to start (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="nodes.list">list</strong></td>
 <td valign="top">[<a href="#node">Node</a>!]!</td>
-<td></td>
+<td>
+
+Materialise every node in the view. Rejected by the server when bulk list
+endpoints are disabled; use `page` for paginated access instead.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="nodes.ids">ids</strong></td>
 <td valign="top">[<a href="#string">String</a>!]!</td>
 <td>
 
-Returns a view of the node ids.
+Every node's id (name) as a flat list of strings. Rejected by the server when
+bulk list endpoints are disabled.
 
 </td>
 </tr>
@@ -5088,34 +6557,76 @@ Returns a view of the node ids.
 <td valign="top"><a href="#nodes">Nodes</a>!</td>
 <td>
 
-Returns a filtered view that applies to list down the chain
+Narrow the collection to nodes matching `expr`. The filter sticks to the
+returned view — every subsequent traversal through these nodes (their
+neighbours, edges, properties) continues to see the filtered scope.
+
+Useful when you want one scoping rule to apply across the whole query.
+E.g. restricting everything to a specific week:
+
+```text
+nodes { filter(expr: {window: {start: 1234, end: 5678}}) {
+list { neighbours { list { name } } }   # neighbours still windowed
+} }
+```
+
+Contrast with `select`, which applies here and is not carried through.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">expr</td>
 <td valign="top"><a href="#nodefilter">NodeFilter</a>!</td>
-<td></td>
+<td>
+
+Composite node filter (by name, property, type, etc.).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="nodes.select">select</strong></td>
 <td valign="top"><a href="#nodes">Nodes</a>!</td>
 <td>
 
-Returns filtered list of nodes
+Narrow the collection to nodes matching `expr`, but only at this step —
+subsequent traversals out of these nodes see the unfiltered graph again.
+
+Useful when you want different scopes at different hops. E.g. nodes
+active on Monday, then their neighbours active on Tuesday, then *those*
+neighbours active on Wednesday:
+
+```text
+nodes { select(expr: {window: {...monday...}}) {
+list { neighbours { select(expr: {window: {...tuesday...}}) {
+list { neighbours { select(expr: {window: {...wednesday...}}) {
+list { name }
+} } }
+} } }
+} }
+```
+
+Contrast with `filter`, which persists the scope through subsequent ops.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">expr</td>
 <td valign="top"><a href="#nodefilter">NodeFilter</a>!</td>
-<td></td>
+<td>
+
+Composite node filter (by name, property, type, etc.).
+
+</td>
 </tr>
 </tbody>
 </table>
 
 ### NodesWindowSet
 
+A lazy sequence of per-window node collections, produced by
+`nodes.rolling` / `nodes.expanding`. Each entry is a `Nodes` collection
+as it exists in that window.
+
 <table>
 <thead>
 <tr>
@@ -5129,7 +6640,12 @@ Returns filtered list of nodes
 <tr>
 <td colspan="2" valign="top"><strong id="nodeswindowset.count">count</strong></td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Number of windows in this set. Materialising all windows is expensive for
+large graphs — prefer `page` over `list` when iterating.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="nodeswindowset.page">page</strong></td>
@@ -5147,22 +6663,39 @@ will be returned.
 <tr>
 <td colspan="2" align="right" valign="top">limit</td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Maximum number of items to return on this page.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">offset</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Extra items to skip on top of `pageIndex` paging (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">pageIndex</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Zero-based page number; multiplies `limit` to determine where to start (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="nodeswindowset.list">list</strong></td>
 <td valign="top">[<a href="#nodes">Nodes</a>!]!</td>
-<td></td>
+<td>
+
+Materialise every window as a list. Rejected by the server when bulk list
+endpoints are disabled; use `page` for paginated access instead.
+
+</td>
 </tr>
 </tbody>
 </table>
@@ -5196,6 +6729,11 @@ PageRank score.
 
 ### PathFromNode
 
+A collection of nodes anchored to a source node — the result of traversals
+like `node.neighbours`, `inNeighbours`, or `outNeighbours`. Supports all
+the usual view transforms (window, layer, filter, ...) and can be chained
+to walk further hops.
+
 <table>
 <thead>
 <tr>
@@ -5218,7 +6756,11 @@ Returns a view of PathFromNode containing the specified layer, errors if the lay
 <tr>
 <td colspan="2" align="right" valign="top">names</td>
 <td valign="top">[<a href="#string">String</a>!]!</td>
-<td></td>
+<td>
+
+Layer names to include.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="pathfromnode.excludelayers">excludeLayers</strong></td>
@@ -5232,7 +6774,11 @@ Return a view of PathFromNode containing all layers except the specified exclude
 <tr>
 <td colspan="2" align="right" valign="top">names</td>
 <td valign="top">[<a href="#string">String</a>!]!</td>
-<td></td>
+<td>
+
+Layer names to exclude.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="pathfromnode.layer">layer</strong></td>
@@ -5246,7 +6792,11 @@ Return a view of PathFromNode containing the layer specified layer, errors if th
 <tr>
 <td colspan="2" align="right" valign="top">name</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Layer name to include.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="pathfromnode.excludelayer">excludeLayer</strong></td>
@@ -5260,7 +6810,11 @@ Return a view of PathFromNode containing all layers except the specified exclude
 <tr>
 <td colspan="2" align="right" valign="top">name</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Layer name to exclude.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="pathfromnode.rolling">rolling</strong></td>
@@ -5282,17 +6836,29 @@ the start of the first window and/or after the end of the last window (i.e. not
 <tr>
 <td colspan="2" align="right" valign="top">window</td>
 <td valign="top"><a href="#windowduration">WindowDuration</a>!</td>
-<td></td>
+<td>
+
+Width of each window. Pass either `{epoch: <ms>}` for a discrete number of milliseconds (e.g. `{epoch: 1000}` for 1 second), or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}` or `{duration: 2 hours and 30 minutes}`).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">step</td>
 <td valign="top"><a href="#windowduration">WindowDuration</a></td>
-<td></td>
+<td>
+
+Optional gap between the start of one window and the start of the next. Accepts the same `{epoch: <ms>}` or `{duration: <text>}` values as `window`. Defaults to `window` — i.e. windows touch end-to-end with no overlap and no gap.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">alignmentUnit</td>
 <td valign="top"><a href="#alignmentunit">AlignmentUnit</a></td>
-<td></td>
+<td>
+
+Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step` (or `window` if no step is set).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="pathfromnode.expanding">expanding</strong></td>
@@ -5312,12 +6878,20 @@ e.g. "1 month and 1 day" will align at the start of the day.
 <tr>
 <td colspan="2" align="right" valign="top">step</td>
 <td valign="top"><a href="#windowduration">WindowDuration</a>!</td>
-<td></td>
+<td>
+
+How much the window grows by on each step. Pass either `{epoch: <ms>}` for a discrete number of milliseconds, or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}`).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">alignmentUnit</td>
 <td valign="top"><a href="#alignmentunit">AlignmentUnit</a></td>
-<td></td>
+<td>
+
+Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step`.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="pathfromnode.window">window</strong></td>
@@ -5331,12 +6905,20 @@ Create a view of the PathFromNode including all events between a specified start
 <tr>
 <td colspan="2" align="right" valign="top">start</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Inclusive lower bound.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">end</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Exclusive upper bound.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="pathfromnode.at">at</strong></td>
@@ -5350,7 +6932,11 @@ Create a view of the PathFromNode including all events at time.
 <tr>
 <td colspan="2" align="right" valign="top">time</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Instant to pin the view to.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="pathfromnode.snapshotlatest">snapshotLatest</strong></td>
@@ -5373,7 +6959,11 @@ Create a view of the PathFromNode including all events that are valid at the spe
 <tr>
 <td colspan="2" align="right" valign="top">time</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Instant at which entities must be valid.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="pathfromnode.latest">latest</strong></td>
@@ -5396,7 +6986,11 @@ Create a view of the PathFromNode including all events before the specified end
 <tr>
 <td colspan="2" align="right" valign="top">time</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Exclusive upper bound.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="pathfromnode.after">after</strong></td>
@@ -5410,7 +7004,11 @@ Create a view of the PathFromNode including all events after the specified start
 <tr>
 <td colspan="2" align="right" valign="top">time</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Exclusive lower bound.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="pathfromnode.shrinkwindow">shrinkWindow</strong></td>
@@ -5424,12 +7022,20 @@ Shrink both the start and end of the window.
 <tr>
 <td colspan="2" align="right" valign="top">start</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Proposed new start (TimeInput); ignored if it would widen the window.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">end</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Proposed new end (TimeInput); ignored if it would widen the window.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="pathfromnode.shrinkstart">shrinkStart</strong></td>
@@ -5443,7 +7049,11 @@ Set the start of the window to the larger of the specified start and self.start(
 <tr>
 <td colspan="2" align="right" valign="top">start</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Proposed new start (TimeInput); ignored if it would widen the window.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="pathfromnode.shrinkend">shrinkEnd</strong></td>
@@ -5457,21 +7067,29 @@ Set the end of the window to the smaller of the specified end and self.end().
 <tr>
 <td colspan="2" align="right" valign="top">end</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+Proposed new end (TimeInput); ignored if it would widen the window.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="pathfromnode.typefilter">typeFilter</strong></td>
 <td valign="top"><a href="#pathfromnode">PathFromNode</a>!</td>
 <td>
 
-Filter nodes by type.
+Narrow this path to neighbours whose node type is in the given set.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">nodeTypes</td>
 <td valign="top">[<a href="#string">String</a>!]!</td>
-<td></td>
+<td>
+
+Node types to keep.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="pathfromnode.start">start</strong></td>
@@ -5494,7 +7112,11 @@ Returns the latest time that this PathFromNode is valid or None if the PathFromN
 <tr>
 <td colspan="2" valign="top"><strong id="pathfromnode.count">count</strong></td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Number of neighbour nodes reachable from the source in this view.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="pathfromnode.page">page</strong></td>
@@ -5512,29 +7134,47 @@ will be returned.
 <tr>
 <td colspan="2" align="right" valign="top">limit</td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Maximum number of items to return on this page.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">offset</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Extra items to skip on top of `pageIndex` paging (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">pageIndex</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Zero-based page number; multiplies `limit` to determine where to start (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="pathfromnode.list">list</strong></td>
 <td valign="top">[<a href="#node">Node</a>!]!</td>
-<td></td>
+<td>
+
+Materialise every neighbour node in the path. Rejected by the server when
+bulk list endpoints are disabled; use `page` for paginated access instead.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="pathfromnode.ids">ids</strong></td>
 <td valign="top">[<a href="#string">String</a>!]!</td>
 <td>
 
-Returns the node ids.
+Every neighbour node's id (name) as a flat list of strings. Rejected by the
+server when bulk list endpoints are disabled.
 
 </td>
 </tr>
@@ -5550,41 +7190,84 @@ Takes a specified selection of views and applies them in given order.
 <tr>
 <td colspan="2" align="right" valign="top">views</td>
 <td valign="top">[<a href="#pathfromnodeviewcollection">PathFromNodeViewCollection</a>!]!</td>
-<td></td>
+<td>
+
+Ordered list of view operations; each entry is a one-of variant (`window`, `layer`, `filter`, ...) applied to the running result.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="pathfromnode.filter">filter</strong></td>
 <td valign="top"><a href="#pathfromnode">PathFromNode</a>!</td>
 <td>
 
-Returns a filtered view that applies to list down the chain
+Narrow the neighbour set to nodes matching `expr`. The filter sticks to
+the returned path — every subsequent traversal (further hops, edges,
+properties) continues to see the filtered scope.
+
+Useful when you want one scoping rule to apply across the whole query.
+E.g. restricting the whole traversal to a specific week:
+
+```text
+node(name: "A") { neighbours { filter(expr: {window: {...week...}}) {
+list { neighbours { list { name } } }   # further hops still windowed
+} } }
+```
+
+Contrast with `select`, which applies here and is not carried through.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">expr</td>
 <td valign="top"><a href="#nodefilter">NodeFilter</a>!</td>
-<td></td>
+<td>
+
+Composite node filter (by name, property, type, etc.).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="pathfromnode.select">select</strong></td>
 <td valign="top"><a href="#pathfromnode">PathFromNode</a>!</td>
 <td>
 
-Returns filtered list of neighbour nodes
+Narrow the neighbour set to nodes matching `expr`, but only at this hop
+— further traversals out of these nodes see the unfiltered graph again.
+
+Useful when each hop needs a different scope. E.g. neighbours active on
+Monday, then *their* neighbours active on Tuesday:
+
+```text
+node(name: "A") { neighbours { select(expr: {window: {...monday...}}) {
+list { neighbours { select(expr: {window: {...tuesday...}}) {
+list { name }
+} } }
+} } }
+```
+
+Contrast with `filter`, which persists the scope through subsequent ops.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">expr</td>
 <td valign="top"><a href="#nodefilter">NodeFilter</a>!</td>
-<td></td>
+<td>
+
+Composite node filter (by name, property, type, etc.).
+
+</td>
 </tr>
 </tbody>
 </table>
 
 ### PathFromNodeWindowSet
 
+A lazy sequence of per-window neighbour sets, produced by
+`neighbours.rolling` / `neighbours.expanding` (or the in/out variants).
+Each entry is a `PathFromNode` scoped to that window.
+
 <table>
 <thead>
 <tr>
@@ -5598,7 +7281,12 @@ Returns filtered list of neighbour nodes
 <tr>
 <td colspan="2" valign="top"><strong id="pathfromnodewindowset.count">count</strong></td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Number of windows in this set. Materialising all windows is expensive for
+large graphs — prefer `page` over `list` when iterating.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="pathfromnodewindowset.page">page</strong></td>
@@ -5616,28 +7304,49 @@ will be returned.
 <tr>
 <td colspan="2" align="right" valign="top">limit</td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Maximum number of items to return on this page.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">offset</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Extra items to skip on top of `pageIndex` paging (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">pageIndex</td>
 <td valign="top"><a href="#int">Int</a></td>
-<td></td>
+<td>
+
+Zero-based page number; multiplies `limit` to determine where to start (default 0).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="pathfromnodewindowset.list">list</strong></td>
 <td valign="top">[<a href="#pathfromnode">PathFromNode</a>!]!</td>
-<td></td>
+<td>
+
+Materialise every window as a list. Rejected by the server when bulk list
+endpoints are disabled; use `page` for paginated access instead.
+
+</td>
 </tr>
 </tbody>
 </table>
 
 ### Properties
 
+All temporal properties of an entity (metadata is exposed separately).
+Look up individual properties via `get` / `contains`, enumerate via
+`keys` / `values`, or drop into `temporal` for time-aware accessors.
+
 <table>
 <thead>
 <tr>
@@ -5653,35 +7362,45 @@ will be returned.
 <td valign="top"><a href="#property">Property</a></td>
 <td>
 
-Get property value matching the specified key.
+Look up a single property by key. Returns null if no property with that key
+exists in the current view.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">key</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+The property name.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="properties.contains">contains</strong></td>
 <td valign="top"><a href="#boolean">Boolean</a>!</td>
 <td>
 
-Check if the key is in the properties.
+Returns true if a property with the given key exists in this view.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">key</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+The property name to look up.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="properties.keys">keys</strong></td>
 <td valign="top">[<a href="#string">String</a>!]!</td>
 <td>
 
-Return all property keys.
+All property keys present in the current view. Does not include metadata
+— metadata is exposed separately via the entity's `metadata` field.
 
 </td>
 </tr>
@@ -5690,25 +7409,38 @@ Return all property keys.
 <td valign="top">[<a href="#property">Property</a>!]!</td>
 <td>
 
-Return all property values.
+Snapshot of property values, one `{key, value}` entry per property.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">keys</td>
 <td valign="top">[<a href="#string">String</a>!]</td>
-<td></td>
+<td>
+
+Optional whitelist. If provided, only properties with these keys are returned; if omitted or null, every property in the view is returned.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="properties.temporal">temporal</strong></td>
 <td valign="top"><a href="#temporalproperties">TemporalProperties</a>!</td>
-<td></td>
+<td>
+
+The temporal-only view of these properties — excludes metadata (which has no
+history) and lets you drill into per-key timelines and aggregates.
+
+</td>
 </tr>
 </tbody>
 </table>
 
 ### Property
 
+A single `(key, value)` property reading at a point in the graph view.
+The value is exposed both as a typed scalar (`value`) and as a
+human-readable string (`asString`).
+
 <table>
 <thead>
 <tr>
@@ -5722,17 +7454,32 @@ Return all property values.
 <tr>
 <td colspan="2" valign="top"><strong id="property.key">key</strong></td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+The property key (name).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="property.asstring">asString</strong></td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+The property value rendered as a human-readable string (e.g. `"10"`, `"hello"`,
+`"2024-01-01T00:00:00Z"`). For programmatic access use `value`, which returns
+a typed scalar.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="property.value">value</strong></td>
 <td valign="top"><a href="#propertyoutput">PropertyOutput</a>!</td>
-<td></td>
+<td>
+
+The property value as a typed `PropertyOutput` scalar — numbers come back as
+numbers, booleans as booleans, strings as strings, etc.
+
+</td>
 </tr>
 </tbody>
 </table>
@@ -5769,6 +7516,10 @@ Return all property values.
 
 ### PropertyTuple
 
+A `(time, value)` pair — the output type of temporal-property accessors
+that need to report *when* a value was observed (e.g. `min`, `max`,
+`median`, `orderedDedupe`).
+
 <table>
 <thead>
 <tr>
@@ -5782,17 +7533,31 @@ Return all property values.
 <tr>
 <td colspan="2" valign="top"><strong id="propertytuple.time">time</strong></td>
 <td valign="top"><a href="#eventtime">EventTime</a>!</td>
-<td></td>
+<td>
+
+The timestamp at which this value was recorded.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="propertytuple.asstring">asString</strong></td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+The value rendered as a human-readable string. For programmatic access use
+`value`, which returns a typed scalar.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="propertytuple.value">value</strong></td>
 <td valign="top"><a href="#propertyoutput">PropertyOutput</a>!</td>
-<td></td>
+<td>
+
+The value as a typed `PropertyOutput` scalar — numbers come back as numbers,
+booleans as booleans, etc.
+
+</td>
 </tr>
 </tbody>
 </table>
@@ -5844,6 +7609,10 @@ Return all property values.
 
 ### TemporalProperties
 
+The temporal-only view of an entity's properties. Each entry is a
+`TemporalProperty` carrying the full timeline for that key — use this when
+you need per-update iteration, time-indexed lookups, or aggregates.
+
 <table>
 <thead>
 <tr>
@@ -5859,35 +7628,44 @@ Return all property values.
 <td valign="top"><a href="#temporalproperty">TemporalProperty</a></td>
 <td>
 
-Get property value matching the specified key.
+Look up a single temporal property by key. Returns null if there's no temporal
+property with that key.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">key</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+The property name.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="temporalproperties.contains">contains</strong></td>
 <td valign="top"><a href="#boolean">Boolean</a>!</td>
 <td>
 
-Check if the key is in the properties.
+Returns true if a temporal property with the given key exists.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">key</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+The property name to look up.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="temporalproperties.keys">keys</strong></td>
 <td valign="top">[<a href="#string">String</a>!]!</td>
 <td>
 
-Return all property keys.
+All temporal-property keys present in this view.
 
 </td>
 </tr>
@@ -5896,20 +7674,30 @@ Return all property keys.
 <td valign="top">[<a href="#temporalproperty">TemporalProperty</a>!]!</td>
 <td>
 
-Return all property values.
+All temporal properties, each as a `TemporalProperty` with its full timeline
+available. Use `history`, `values`, `latest`, `at`, etc. on each entry.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">keys</td>
 <td valign="top">[<a href="#string">String</a>!]</td>
-<td></td>
+<td>
+
+Optional whitelist. If provided, only temporal properties with these keys are returned; if omitted, every temporal property in the view is returned.
+
+</td>
 </tr>
 </tbody>
 </table>
 
 ### TemporalProperty
 
+The full timeline of a single property key on one entity. Exposes every
+update (via `values` / `history` / `orderedDedupe`), point lookups (`at`,
+`latest`), and aggregates over the timeline (`sum`, `mean`, `min`, `max`,
+`median`, `count`).
+
 <table>
 <thead>
 <tr>
@@ -5925,59 +7713,165 @@ Return all property values.
 <td valign="top"><a href="#string">String</a>!</td>
 <td>
 
-Key of a property.
+The property key (name).
 
 </td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="temporalproperty.history">history</strong></td>
 <td valign="top"><a href="#history">History</a>!</td>
-<td></td>
+<td>
+
+Event history for this property — one entry per temporal update, in
+insertion order. Use this to navigate the full timeline: access the
+raw `timestamps` / `datetimes` / `eventId` lists, analyse gaps between
+updates via `intervals` (mean/median/min/max), ask `isEmpty`, or
+paginate the events.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="temporalproperty.values">values</strong></td>
-<td valign="top">[<a href="#string">String</a>!]!</td>
+<td valign="top">[<a href="#propertyoutput">PropertyOutput</a>!]!</td>
 <td>
 
-Return the values of the properties.
+All values this property has ever taken, in temporal order (one per update).
+Typed as `PropertyOutput` so numeric values stay numeric.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="temporalproperty.at">at</strong></td>
-<td valign="top"><a href="#string">String</a></td>
-<td></td>
+<td valign="top"><a href="#propertyoutput">PropertyOutput</a></td>
+<td>
+
+The value at or before time `t` (latest update on or before `t`). Returns null
+if no update exists on or before `t`.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">t</td>
 <td valign="top"><a href="#timeinput">TimeInput</a>!</td>
-<td></td>
+<td>
+
+A TimeInput (epoch millis integer, RFC3339 string, or `{timestamp, eventId}` object).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="temporalproperty.latest">latest</strong></td>
-<td valign="top"><a href="#string">String</a></td>
-<td></td>
+<td valign="top"><a href="#propertyoutput">PropertyOutput</a></td>
+<td>
+
+The most recent value, or null if the property has never been set in this view.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="temporalproperty.unique">unique</strong></td>
-<td valign="top">[<a href="#string">String</a>!]!</td>
-<td></td>
+<td valign="top">[<a href="#propertyoutput">PropertyOutput</a>!]!</td>
+<td>
+
+The set of distinct values this property has ever taken (order not guaranteed).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="temporalproperty.ordereddedupe">orderedDedupe</strong></td>
 <td valign="top">[<a href="#propertytuple">PropertyTuple</a>!]!</td>
-<td></td>
+<td>
+
+Collapses runs of consecutive-equal updates into a single `(time, value)` pair.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">latestTime</td>
 <td valign="top"><a href="#boolean">Boolean</a>!</td>
-<td></td>
+<td>
+
+If true, each run is represented by its *last* timestamp; if false, by its *first*. Useful for compressing chatter in a timeline.
+
+</td>
+</tr>
+<tr>
+<td colspan="2" valign="top"><strong id="temporalproperty.sum">sum</strong></td>
+<td valign="top"><a href="#propertyoutput">PropertyOutput</a></td>
+<td>
+
+Sum of all updates. Returns null if the dtype is not additive or the property is empty.
+
+</td>
+</tr>
+<tr>
+<td colspan="2" valign="top"><strong id="temporalproperty.mean">mean</strong></td>
+<td valign="top"><a href="#propertyoutput">PropertyOutput</a></td>
+<td>
+
+Mean of all updates as an F64. Returns null if any value is non-numeric or the property is
+empty.
+
+</td>
+</tr>
+<tr>
+<td colspan="2" valign="top"><strong id="temporalproperty.average">average</strong></td>
+<td valign="top"><a href="#propertyoutput">PropertyOutput</a></td>
+<td>
+
+Alias for `mean` — same F64 average, same null cases.
+
+</td>
+</tr>
+<tr>
+<td colspan="2" valign="top"><strong id="temporalproperty.min">min</strong></td>
+<td valign="top"><a href="#propertytuple">PropertyTuple</a></td>
+<td>
+
+Minimum `(time, value)` pair. Returns null if the dtype is not comparable or the property is
+empty.
+
+</td>
+</tr>
+<tr>
+<td colspan="2" valign="top"><strong id="temporalproperty.max">max</strong></td>
+<td valign="top"><a href="#propertytuple">PropertyTuple</a></td>
+<td>
+
+Maximum `(time, value)` pair. Returns null if the dtype is not comparable or the property is
+empty.
+
+</td>
+</tr>
+<tr>
+<td colspan="2" valign="top"><strong id="temporalproperty.median">median</strong></td>
+<td valign="top"><a href="#propertytuple">PropertyTuple</a></td>
+<td>
+
+Median `(time, value)` pair (lower median on even-length inputs). Returns null if the dtype
+is not comparable or the property is empty.
+
+</td>
+</tr>
+<tr>
+<td colspan="2" valign="top"><strong id="temporalproperty.count">count</strong></td>
+<td valign="top"><a href="#int">Int</a>!</td>
+<td>
+
+Number of updates recorded for this property in the current view.
+
+</td>
 </tr>
 </tbody>
 </table>
 
 ### VectorSelection
 
+A working set of documents / nodes / edges built up via similarity
+searches on a `VectorisedGraph`. Selections are mutable: you can grow
+them with more hops (`expand*`), dereference the contents (`nodes`,
+`edges`, `getDocuments`), or start fresh with `emptySelection`.
+
 <table>
 <thead>
 <tr>
@@ -6020,131 +7914,191 @@ Returns a list of documents in the current selection.
 <td valign="top"><a href="#vectorselection">VectorSelection</a>!</td>
 <td>
 
-Adds all the documents associated with the specified nodes to the current selection.
-
-Documents added by this call are assumed to have a score of 0.
+Add every document associated with the named nodes to the selection.
+Documents added this way receive a score of 0 (no similarity ranking).
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">nodes</td>
-<td valign="top">[<a href="#string">String</a>!]!</td>
-<td></td>
+<td valign="top">[<a href="#nodeid">NodeId</a>!]!</td>
+<td>
+
+Node ids whose documents to include.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="vectorselection.addedges">addEdges</strong></td>
 <td valign="top"><a href="#vectorselection">VectorSelection</a>!</td>
 <td>
 
-Adds all the documents associated with the specified edges to the current selection.
-
-Documents added by this call are assumed to have a score of 0.
+Add every document associated with the named edges to the selection.
+Documents added this way receive a score of 0 (no similarity ranking).
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">edges</td>
 <td valign="top">[<a href="#inputedge">InputEdge</a>!]!</td>
-<td></td>
+<td>
+
+List of `{src, dst}` pairs identifying the edges.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="vectorselection.expand">expand</strong></td>
 <td valign="top"><a href="#vectorselection">VectorSelection</a>!</td>
 <td>
 
-Add all the documents a specified number of hops away to the selection.
-
-Two documents A and B are considered to be 1 hop away of each other if they are on the same entity or if they are on the same node and edge pair.
+Grow the selection by including documents that are within `hops` of any
+document already in the selection. Two documents are 1 hop apart if
+they're on the same entity or on a connected node/edge pair.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">hops</td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Number of expansion rounds (1 = direct neighbours).
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">window</td>
 <td valign="top"><a href="#vectorisedgraphwindow">VectorisedGraphWindow</a></td>
-<td></td>
+<td>
+
+Optional `{start, end}` to restrict expansion to entities active in that interval.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="vectorselection.expandentitiesbysimilarity">expandEntitiesBySimilarity</strong></td>
 <td valign="top"><a href="#vectorselection">VectorSelection</a>!</td>
 <td>
 
-Adds documents, from the set of one hop neighbours to the current selection, to the selection based on their similarity score with the specified query. This function loops so that the set of one hop neighbours expands on each loop and number of documents added is determined by the specified limit.
+Iteratively expand the selection by similarity to a natural-language
+query. Each pass takes the one-hop neighbour set of the current
+selection and adds the highest-scoring entities (mixed nodes and
+edges); the loop continues until `limit` entities have been added.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">query</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Natural-language search string; embedded by the server.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">limit</td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Total number of entities to add across all passes.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">window</td>
 <td valign="top"><a href="#vectorisedgraphwindow">VectorisedGraphWindow</a></td>
-<td></td>
+<td>
+
+Optional `{start, end}` to restrict matches to entities active in that interval.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="vectorselection.expandnodesbysimilarity">expandNodesBySimilarity</strong></td>
 <td valign="top"><a href="#vectorselection">VectorSelection</a>!</td>
 <td>
 
-Add the adjacent nodes with higher score for query to the selection up to a specified limit. This function loops like expand_entities_by_similarity but is restricted to nodes.
+Like `expandEntitiesBySimilarity` but restricted to nodes — iteratively
+add the highest-scoring adjacent nodes to the selection.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">query</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Natural-language search string; embedded by the server.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">limit</td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Total number of nodes to add across all passes.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">window</td>
 <td valign="top"><a href="#vectorisedgraphwindow">VectorisedGraphWindow</a></td>
-<td></td>
+<td>
+
+Optional `{start, end}` to restrict matches to nodes active in that interval.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="vectorselection.expandedgesbysimilarity">expandEdgesBySimilarity</strong></td>
 <td valign="top"><a href="#vectorselection">VectorSelection</a>!</td>
 <td>
 
-Add the adjacent edges with higher score for query to the selection up to a specified limit. This function loops like expand_entities_by_similarity but is restricted to edges.
+Like `expandEntitiesBySimilarity` but restricted to edges — iteratively
+add the highest-scoring adjacent edges to the selection.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">query</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Natural-language search string; embedded by the server.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">limit</td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Total number of edges to add across all passes.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">window</td>
 <td valign="top"><a href="#vectorisedgraphwindow">VectorisedGraphWindow</a></td>
-<td></td>
+<td>
+
+Optional `{start, end}` to restrict matches to edges active in that interval.
+
+</td>
 </tr>
 </tbody>
 </table>
 
 ### VectorisedGraph
 
+A graph with embedded vector representations for its nodes and edges.
+Exposes similarity search over documents, nodes, and edges, plus
+selection building (`emptySelection`) and index maintenance
+(`optimizeIndex`).
+
 <table>
 <thead>
 <tr>
@@ -6160,7 +8114,9 @@ Add the adjacent edges with higher score for query to the selection up to a spec
 <td valign="top"><a href="#boolean">Boolean</a>!</td>
 <td>
 
-Optmize the vector index
+Rebuild (or incrementally update) the on-disk vector indexes for nodes
+and edges so subsequent similarity searches hit the fresh embeddings.
+Safe to call repeatedly; returns true on success.
 
 </td>
 </tr>
@@ -6178,72 +8134,114 @@ Returns an empty selection of documents.
 <td valign="top"><a href="#vectorselection">VectorSelection</a>!</td>
 <td>
 
-Search the top scoring entities according to a specified query returning no more than a specified limit of entities.
+Find the highest-scoring nodes *and* edges (mixed) by similarity to a
+natural-language query. The query is embedded server-side and matched
+against indexed entity vectors.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">query</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Natural-language search string; embedded by the server.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">limit</td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Maximum number of results to return.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">window</td>
 <td valign="top"><a href="#vectorisedgraphwindow">VectorisedGraphWindow</a></td>
-<td></td>
+<td>
+
+Optional `{start, end}` to restrict matches to entities active in that interval.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="vectorisedgraph.nodesbysimilarity">nodesBySimilarity</strong></td>
 <td valign="top"><a href="#vectorselection">VectorSelection</a>!</td>
 <td>
 
-Search the top scoring nodes according to a specified query returning no more than a specified limit of nodes.
+Find the highest-scoring nodes by similarity to a natural-language
+query. The query is embedded server-side and matched against indexed
+node vectors.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">query</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Natural-language search string; embedded by the server.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">limit</td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Maximum number of nodes to return.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">window</td>
 <td valign="top"><a href="#vectorisedgraphwindow">VectorisedGraphWindow</a></td>
-<td></td>
+<td>
+
+Optional `{start, end}` to restrict matches to nodes active in that interval.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="vectorisedgraph.edgesbysimilarity">edgesBySimilarity</strong></td>
 <td valign="top"><a href="#vectorselection">VectorSelection</a>!</td>
 <td>
 
-Search the top scoring edges according to a specified query returning no more than a specified limit of edges.
+Find the highest-scoring edges by similarity to a natural-language
+query. The query is embedded server-side and matched against indexed
+edge vectors.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">query</td>
 <td valign="top"><a href="#string">String</a>!</td>
-<td></td>
+<td>
+
+Natural-language search string; embedded by the server.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">limit</td>
 <td valign="top"><a href="#int">Int</a>!</td>
-<td></td>
+<td>
+
+Maximum number of edges to return.
+
+</td>
 </tr>
 <tr>
 <td colspan="2" align="right" valign="top">window</td>
 <td valign="top"><a href="#vectorisedgraphwindow">VectorisedGraphWindow</a></td>
-<td></td>
+<td>
+
+Optional `{start, end}` to restrict matches to edges active in that interval.
+
+</td>
 </tr>
 </tbody>
 </table>
@@ -6263,19 +8261,19 @@ Search the top scoring edges according to a specified query returning no more th
 <tbody>
 <tr>
 <td colspan="2" valign="top"><strong id="edgeaddition.src">src</strong></td>
-<td valign="top"><a href="#string">String</a>!</td>
+<td valign="top"><a href="#nodeid">NodeId</a>!</td>
 <td>
 
-Source node.
+Source node id (string or non-negative integer).
 
 </td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="edgeaddition.dst">dst</strong></td>
-<td valign="top"><a href="#string">String</a>!</td>
+<td valign="top"><a href="#nodeid">NodeId</a>!</td>
 <td>
 
-Destination node.
+Destination node id (string or non-negative integer).
 
 </td>
 </tr>
@@ -7356,7 +9354,7 @@ Single excluded layer.
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="graphviewcollection.subgraph">subgraph</strong></td>
-<td valign="top">[<a href="#string">String</a>!]</td>
+<td valign="top">[<a href="#nodeid">NodeId</a>!]</td>
 <td>
 
 Subgraph nodes.
@@ -7374,7 +9372,7 @@ Subgraph node types.
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="graphviewcollection.excludenodes">excludeNodes</strong></td>
-<td valign="top">[<a href="#string">String</a>!]</td>
+<td valign="top">[<a href="#nodeid">NodeId</a>!]</td>
 <td>
 
 List of excluded nodes.
@@ -7599,19 +9597,19 @@ Edge properties.
 <tbody>
 <tr>
 <td colspan="2" valign="top"><strong id="inputedge.src">src</strong></td>
-<td valign="top"><a href="#string">String</a>!</td>
+<td valign="top"><a href="#nodeid">NodeId</a>!</td>
 <td>
 
-Source node.
+Source node id (string or non-negative integer).
 
 </td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="inputedge.dst">dst</strong></td>
-<td valign="top"><a href="#string">String</a>!</td>
+<td valign="top"><a href="#nodeid">NodeId</a>!</td>
 <td>
 
-Destination node.
+Destination node id (string or non-negative integer).
 
 </td>
 </tr>
@@ -7631,10 +9629,10 @@ Destination node.
 <tbody>
 <tr>
 <td colspan="2" valign="top"><strong id="nodeaddition.name">name</strong></td>
-<td valign="top"><a href="#string">String</a>!</td>
+<td valign="top"><a href="#nodeid">NodeId</a>!</td>
 <td>
 
-Name.
+Node id (string or non-negative integer).
 
 </td>
 </tr>
@@ -7663,6 +9661,15 @@ Metadata.
 
 Updates.
 
+</td>
+</tr>
+<tr>
+<td colspan="2" valign="top"><strong id="nodeaddition.layer">layer</strong></td>
+<td valign="top"><a href="#string">String</a></td>
+<td>
+
+Layer.
+
 </td>
 </tr>
 </tbody>
@@ -9185,10 +11192,11 @@ A custom template.
 <tbody>
 <tr>
 <td colspan="2" valign="top"><strong id="temporalpropertyinput.time">time</strong></td>
-<td valign="top"><a href="#int">Int</a>!</td>
+<td valign="top"><a href="#timeinput">TimeInput</a>!</td>
 <td>
 
-Time.
+Time of the update — accepts the same forms as `TimeInput` (epoch
+millis Int, RFC3339 string, or `{timestamp, eventId}` object).
 
 </td>
 </tr>
@@ -9321,6 +11329,33 @@ List.
 
 Object.
 
+</td>
+</tr>
+<tr>
+<td colspan="2" valign="top"><strong id="value.dtime">dtime</strong></td>
+<td valign="top"><a href="#string">String</a></td>
+<td>
+
+Timezone-aware datetime.
+
+</td>
+</tr>
+<tr>
+<td colspan="2" valign="top"><strong id="value.ndtime">ndtime</strong></td>
+<td valign="top"><a href="#string">String</a></td>
+<td>
+
+Naive datetime (no timezone).
+
+</td>
+</tr>
+<tr>
+<td colspan="2" valign="top"><strong id="value.decimal">decimal</strong></td>
+<td valign="top"><a href="#string">String</a></td>
+<td>
+
+BigDecimal number (string representation, e.g. "3.14159" or "123e-5").
+
 </td>
 </tr>
 </tbody>
@@ -9339,19 +11374,19 @@ Object.
 <tbody>
 <tr>
 <td colspan="2" valign="top"><strong id="vectorisedgraphwindow.start">start</strong></td>
-<td valign="top"><a href="#int">Int</a>!</td>
+<td valign="top"><a href="#timeinput">TimeInput</a>!</td>
 <td>
 
-Start time.
+Inclusive lower bound of the search window.
 
 </td>
 </tr>
 <tr>
 <td colspan="2" valign="top"><strong id="vectorisedgraphwindow.end">end</strong></td>
-<td valign="top"><a href="#int">Int</a>!</td>
+<td valign="top"><a href="#timeinput">TimeInput</a>!</td>
 <td>
 
-End time.
+Exclusive upper bound of the search window.
 
 </td>
 </tr>
@@ -9629,6 +11664,12 @@ The `Float` scalar type represents signed double-precision fractional values as
 
 The `Int` scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1.
 
+### NodeId
+
+Identifier for a node — either a string (`"alice"`) or a non-negative
+integer (`42`). Use whichever form matches how the graph was indexed
+when nodes were added.
+
 ### PropertyOutput
 
 ### String
@@ -9642,6 +11683,11 @@ where the timestamp is either an Int or a DateTime formatted String, and eventId
 Valid string formats are RFC3339, RFC2822, %Y-%m-%d, %Y-%m-%dT%H:%M:%S%.3f, %Y-%m-%dT%H:%M:%S%,
 %Y-%m-%d %H:%M:%S%.3f and %Y-%m-%d %H:%M:%S%.
 
+Internally wraps `InputTime` so write paths (`addNode`, `addEdge`,
+`addProperties`, etc.) can preserve auto-increment of `event_id` when only
+a timestamp is given. Pass the object form `{timestamp, eventId}` to lock
+the event_id explicitly.
+
 ### Upload
 
 A multipart file upload
@@ -9692,11 +11738,25 @@ Raphtory graph edge.
 <tbody>
 <tr>
 <td valign="top"><strong><a href="#namespace">Namespace</a></strong></td>
-<td></td>
+<td valign="top">
+
+A directory-like container for graphs and nested namespaces. Graphs are
+addressed by path (e.g. `"team/project/graph"`), and every segment except
+the last is a namespace. Use to browse what's stored on the server without
+loading any graph data.
+
+</td>
 </tr>
 <tr>
 <td valign="top"><strong><a href="#metagraph">MetaGraph</a></strong></td>
-<td></td>
+<td valign="top">
+
+Lightweight summary of a stored graph — its name, path, counts, and
+filesystem timestamps — served without deserializing the full graph.
+Useful for listing what's available on the server before committing to a
+full load.
+
+</td>
 </tr>
 </tbody>
 </table>
diff --git a/docs/src/rust/home/example.rs b/docs/src/rust/home/example.rs
deleted file mode 100644
index 0b3603df73..0000000000
--- a/docs/src/rust/home/example.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-fn main() -> Result<(), Box<dyn std::error::Error>>{
-
-    // --8<-- [start:example]
-    println!("RUST stub")
-    // --8<-- [end:example]
-
-    Ok(())
-}
diff --git a/examples/custom-gql-apis/Cargo.toml b/examples/custom-gql-apis/Cargo.toml
index 4074e14ab0..fa19368e0d 100644
--- a/examples/custom-gql-apis/Cargo.toml
+++ b/examples/custom-gql-apis/Cargo.toml
@@ -4,7 +4,7 @@ description = "Python package for raphtory, a temporal graph library"
 version = "0.9.3"
 keywords = ["graph", "temporal-graph", "temporal", "jira"]
 authors = ["Pometry"]
-rust-version = "1.75.0"
+rust-version = "1.89.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html[lib]
diff --git a/examples/custom-gql-apis/src/mutation.rs b/examples/custom-gql-apis/src/mutation.rs
index e48e421a7f..a836f400b9 100644
--- a/examples/custom-gql-apis/src/mutation.rs
+++ b/examples/custom-gql-apis/src/mutation.rs
@@ -20,7 +20,7 @@ impl<'a> Operation<'a, MutationPlugin> for HelloMutation {
 
     fn apply<'b>(
         _entry_point: &MutationPlugin,
-        ctx: ResolverContext,
+        ctx: ResolverContext<'b>,
     ) -> BoxFuture<'b, FieldResult<Option<FieldValue<'b>>>> {
         let name = ctx
             .args
diff --git a/examples/custom-gql-apis/src/query.rs b/examples/custom-gql-apis/src/query.rs
index 453d127f61..7c5e226346 100644
--- a/examples/custom-gql-apis/src/query.rs
+++ b/examples/custom-gql-apis/src/query.rs
@@ -20,7 +20,7 @@ impl<'a> Operation<'a, QueryPlugin> for HelloQuery {
 
     fn apply<'b>(
         _entry_point: &QueryPlugin,
-        ctx: ResolverContext,
+        ctx: ResolverContext<'b>,
     ) -> BoxFuture<'b, FieldResult<Option<FieldValue<'b>>>> {
         let name = ctx
             .args
diff --git a/examples/netflow/src/netflow_one_path_node.rs b/examples/netflow/src/netflow_one_path_node.rs
index c6567436c6..95c3393e95 100644
--- a/examples/netflow/src/netflow_one_path_node.rs
+++ b/examples/netflow/src/netflow_one_path_node.rs
@@ -122,7 +122,7 @@ pub fn netflow_one_path_node<G: StaticGraphViewOps>(
         vec![],
         vec![Job::new(step1)],
         None,
-        |egs, _, _, _| egs.finalize(&total_value),
+        |egs, _, _, _, _| egs.finalize(&total_value),
         threads,
         1,
         None,
diff --git a/examples/python/enron/nx.html b/examples/python/enron/nx.html
index d4d35188ac..8ef2dbb6cb 100644
--- a/examples/python/enron/nx.html
+++ b/examples/python/enron/nx.html
@@ -1,155 +1,272 @@
 <html>
     <head>
-        <meta charset="utf-8">
-        
-            <script src="lib/bindings/utils.js"></script>
-            <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/vis-network/9.1.2/dist/dist/vis-network.min.css" integrity="sha512-WgxfT5LWjfszlPHXRmBWHkV2eceiWTOBvrKCNbdgDYTHrT2AeLCGbF4sZlZw3UMN3WtL0tGUoIAKsu8mllg/XA==" crossorigin="anonymous" referrerpolicy="no-referrer" />
-            <script src="https://cdnjs.cloudflare.com/ajax/libs/vis-network/9.1.2/dist/vis-network.min.js" integrity="sha512-LnvoEWDFrqGHlHmDD2101OrLcbsfkrzoSpvtSQtxK3RMnRV0eOkhhBN2dXHKRrUU8p2DGRTk35n4O8nWSVe1mQ==" crossorigin="anonymous" referrerpolicy="no-referrer"></script>
-            
-        
-<center>
-<h1></h1>
-</center>
+        <meta charset="utf-8" />
 
-<!-- <link rel="stylesheet" href="../node_modules/vis/dist/vis.min.css" type="text/css" />
-<script type="text/javascript" src="../node_modules/vis/dist/vis.js"> </script>-->
+        <script src="lib/bindings/utils.js"></script>
         <link
-          href="https://cdn.jsdelivr.net/npm/bootstrap@5.0.0-beta3/dist/css/bootstrap.min.css"
-          rel="stylesheet"
-          integrity="sha384-eOJMYsd53ii+scO/bJGFsiCZc+5NDVN2yr8+0RDqr0Ql0h+rP48ckxlpbzKgwra6"
-          crossorigin="anonymous"
+            rel="stylesheet"
+            href="https://cdnjs.cloudflare.com/ajax/libs/vis-network/9.1.2/dist/dist/vis-network.min.css"
+            integrity="sha512-WgxfT5LWjfszlPHXRmBWHkV2eceiWTOBvrKCNbdgDYTHrT2AeLCGbF4sZlZw3UMN3WtL0tGUoIAKsu8mllg/XA=="
+            crossorigin="anonymous"
+            referrerpolicy="no-referrer"
         />
         <script
-          src="https://cdn.jsdelivr.net/npm/bootstrap@5.0.0-beta3/dist/js/bootstrap.bundle.min.js"
-          integrity="sha384-JEW9xMcG8R+pH31jmWH6WWP0WintQrMb4s7ZOdauHnUtxwoG2vI5DkLtS3qm9Ekf"
-          crossorigin="anonymous"
+            src="https://cdnjs.cloudflare.com/ajax/libs/vis-network/9.1.2/dist/vis-network.min.js"
+            integrity="sha512-LnvoEWDFrqGHlHmDD2101OrLcbsfkrzoSpvtSQtxK3RMnRV0eOkhhBN2dXHKRrUU8p2DGRTk35n4O8nWSVe1mQ=="
+            crossorigin="anonymous"
+            referrerpolicy="no-referrer"
         ></script>
 
-
         <center>
-          <h1></h1>
+            <h1></h1>
         </center>
-        <style type="text/css">
-
-             #mynetwork {
-                 width: 100%;
-                 height: 600px;
-                 background-color: #ffffff;
-                 border: 1px solid lightgray;
-                 position: relative;
-                 float: left;
-             }
 
-             
-
-             
+        <!-- <link rel="stylesheet" href="../node_modules/vis/dist/vis.min.css" type="text/css" />
+<script type="text/javascript" src="../node_modules/vis/dist/vis.js"> </script>-->
+        <link
+            href="https://cdn.jsdelivr.net/npm/bootstrap@5.0.0-beta3/dist/css/bootstrap.min.css"
+            rel="stylesheet"
+            integrity="sha384-eOJMYsd53ii+scO/bJGFsiCZc+5NDVN2yr8+0RDqr0Ql0h+rP48ckxlpbzKgwra6"
+            crossorigin="anonymous"
+        />
+        <script
+            src="https://cdn.jsdelivr.net/npm/bootstrap@5.0.0-beta3/dist/js/bootstrap.bundle.min.js"
+            integrity="sha384-JEW9xMcG8R+pH31jmWH6WWP0WintQrMb4s7ZOdauHnUtxwoG2vI5DkLtS3qm9Ekf"
+            crossorigin="anonymous"
+        ></script>
 
-             
+        <center>
+            <h1></h1>
+        </center>
+        <style type="text/css">
+            #mynetwork {
+                width: 100%;
+                height: 600px;
+                background-color: #ffffff;
+                border: 1px solid lightgray;
+                position: relative;
+                float: left;
+            }
         </style>
     </head>
 
-
     <body>
         <div class="card" style="width: 100%">
-            
-            
             <div id="mynetwork" class="card-body"></div>
         </div>
 
-        
-        
-
         <script type="text/javascript">
+            // initialize global variables.
+            var edges;
+            var nodes;
+            var allNodes;
+            var allEdges;
+            var nodeColors;
+            var originalNodes;
+            var network;
+            var container;
+            var options, data;
+            var filter = {
+                item: "",
+                property: "",
+                value: [],
+            };
 
-              // initialize global variables.
-              var edges;
-              var nodes;
-              var allNodes;
-              var allEdges;
-              var nodeColors;
-              var originalNodes;
-              var network;
-              var container;
-              var options, data;
-              var filter = {
-                  item : '',
-                  property : '',
-                  value : []
-              };
-
-              
-
-              
-
-              // This method is responsible for drawing the graph, returns the drawn network
-              function drawGraph() {
-                  var container = document.getElementById('mynetwork');
+            // This method is responsible for drawing the graph, returns the drawn network
+            function drawGraph() {
+                var container = document.getElementById("mynetwork");
 
-                  
+                // parsing and collecting nodes and edges from the python
+                nodes = new vis.DataSet([
+                    {
+                        color: "#97c2fc",
+                        id: 6076003423996713654,
+                        image: "https://cdn-icons-png.flaticon.com/512/7584/7584620.png",
+                        label: "greg.whalley",
+                        shape: "dot",
+                    },
+                    {
+                        color: "#97c2fc",
+                        id: 3706582846319807979,
+                        image: "https://cdn-icons-png.flaticon.com/512/7584/7584620.png",
+                        label: "michael.norris",
+                        shape: "dot",
+                    },
+                    {
+                        color: "#97c2fc",
+                        id: 5350559918789963524,
+                        image: "https://cdn-icons-png.flaticon.com/512/7584/7584620.png",
+                        label: "w..pereira",
+                        shape: "dot",
+                    },
+                    {
+                        color: "#97c2fc",
+                        id: 4166911038501177767,
+                        image: "https://cdn-icons-png.flaticon.com/512/7584/7584620.png",
+                        label: "kenneth.lay",
+                        shape: "dot",
+                    },
+                    {
+                        color: "#97c2fc",
+                        id: 15621484258632277716,
+                        image: "https://cdn-icons-png.flaticon.com/512/7584/7584620.png",
+                        label: "a..howard",
+                        shape: "dot",
+                    },
+                    {
+                        color: "#97c2fc",
+                        id: 11195289028662148947,
+                        image: "https://cdn-icons-png.flaticon.com/512/7584/7584620.png",
+                        label: "rod.hayslett",
+                        shape: "dot",
+                    },
+                    {
+                        color: "#97c2fc",
+                        id: 7142029215401505166,
+                        image: "https://cdn-icons-png.flaticon.com/512/7584/7584620.png",
+                        label: "stanley.horton",
+                        shape: "dot",
+                    },
+                    {
+                        color: "#97c2fc",
+                        id: 1598159658826880704,
+                        image: "https://cdn-icons-png.flaticon.com/512/7584/7584620.png",
+                        label: "khortongolf",
+                        shape: "dot",
+                    },
+                    {
+                        color: "#97c2fc",
+                        id: 3135071489733153058,
+                        image: "https://cdn-icons-png.flaticon.com/512/7584/7584620.png",
+                        label: "betty.alexander",
+                        shape: "dot",
+                    },
+                    {
+                        color: "#97c2fc",
+                        id: 4916201938344921332,
+                        image: "https://cdn-icons-png.flaticon.com/512/7584/7584620.png",
+                        label: "deane.pierce",
+                        shape: "dot",
+                    },
+                    {
+                        color: "#97c2fc",
+                        id: 8336200709397585546,
+                        image: "https://cdn-icons-png.flaticon.com/512/7584/7584620.png",
+                        label: "a..hughes",
+                        shape: "dot",
+                    },
+                ]);
+                edges = new vis.DataSet([
+                    {
+                        arrowStrikethrough: false,
+                        color: "#FF0000",
+                        from: 6076003423996713654,
+                        title: "",
+                        to: 3706582846319807979,
+                        value: 1,
+                    },
+                    {
+                        arrowStrikethrough: false,
+                        color: "#FF0000",
+                        from: 5350559918789963524,
+                        title: "",
+                        to: 4166911038501177767,
+                        value: 1,
+                    },
+                    {
+                        arrowStrikethrough: false,
+                        color: "#FF0000",
+                        from: 15621484258632277716,
+                        title: "",
+                        to: 11195289028662148947,
+                        value: 1,
+                    },
+                    {
+                        arrowStrikethrough: false,
+                        color: "#FF0000",
+                        from: 3706582846319807979,
+                        title: "",
+                        to: 4166911038501177767,
+                        value: 1,
+                    },
+                    {
+                        arrowStrikethrough: false,
+                        color: "#FF0000",
+                        from: 7142029215401505166,
+                        title: "",
+                        to: 1598159658826880704,
+                        value: 1,
+                    },
+                    {
+                        arrowStrikethrough: false,
+                        color: "#FF0000",
+                        from: 3135071489733153058,
+                        title: "",
+                        to: 4166911038501177767,
+                        value: 1,
+                    },
+                    {
+                        arrowStrikethrough: false,
+                        color: "#FF0000",
+                        from: 4916201938344921332,
+                        title: "",
+                        to: 4166911038501177767,
+                        value: 1,
+                    },
+                    {
+                        arrowStrikethrough: false,
+                        color: "#FF0000",
+                        from: 8336200709397585546,
+                        title: "",
+                        to: 7142029215401505166,
+                        value: 1,
+                    },
+                ]);
 
-                  // parsing and collecting nodes and edges from the python
-                  nodes = new vis.DataSet([{"color": "#97c2fc", "id": 6076003423996713654, "image": "https://cdn-icons-png.flaticon.com/512/7584/7584620.png", "label": "greg.whalley", "shape": "dot"}, {"color": "#97c2fc", "id": 3706582846319807979, "image": "https://cdn-icons-png.flaticon.com/512/7584/7584620.png", "label": "michael.norris", "shape": "dot"}, {"color": "#97c2fc", "id": 5350559918789963524, "image": "https://cdn-icons-png.flaticon.com/512/7584/7584620.png", "label": "w..pereira", "shape": "dot"}, {"color": "#97c2fc", "id": 4166911038501177767, "image": "https://cdn-icons-png.flaticon.com/512/7584/7584620.png", "label": "kenneth.lay", "shape": "dot"}, {"color": "#97c2fc", "id": 15621484258632277716, "image": "https://cdn-icons-png.flaticon.com/512/7584/7584620.png", "label": "a..howard", "shape": "dot"}, {"color": "#97c2fc", "id": 11195289028662148947, "image": "https://cdn-icons-png.flaticon.com/512/7584/7584620.png", "label": "rod.hayslett", "shape": "dot"}, {"color": "#97c2fc", "id": 7142029215401505166, "image": "https://cdn-icons-png.flaticon.com/512/7584/7584620.png", "label": "stanley.horton", "shape": "dot"}, {"color": "#97c2fc", "id": 1598159658826880704, "image": "https://cdn-icons-png.flaticon.com/512/7584/7584620.png", "label": "khortongolf", "shape": "dot"}, {"color": "#97c2fc", "id": 3135071489733153058, "image": "https://cdn-icons-png.flaticon.com/512/7584/7584620.png", "label": "betty.alexander", "shape": "dot"}, {"color": "#97c2fc", "id": 4916201938344921332, "image": "https://cdn-icons-png.flaticon.com/512/7584/7584620.png", "label": "deane.pierce", "shape": "dot"}, {"color": "#97c2fc", "id": 8336200709397585546, "image": "https://cdn-icons-png.flaticon.com/512/7584/7584620.png", "label": "a..hughes", "shape": "dot"}]);
-                  edges = new vis.DataSet([{"arrowStrikethrough": false, "color": "#FF0000", "from": 6076003423996713654, "title": "", "to": 3706582846319807979, "value": 1}, {"arrowStrikethrough": false, "color": "#FF0000", "from": 5350559918789963524, "title": "", "to": 4166911038501177767, "value": 1}, {"arrowStrikethrough": false, "color": "#FF0000", "from": 15621484258632277716, "title": "", "to": 11195289028662148947, "value": 1}, {"arrowStrikethrough": false, "color": "#FF0000", "from": 3706582846319807979, "title": "", "to": 4166911038501177767, "value": 1}, {"arrowStrikethrough": false, "color": "#FF0000", "from": 7142029215401505166, "title": "", "to": 1598159658826880704, "value": 1}, {"arrowStrikethrough": false, "color": "#FF0000", "from": 3135071489733153058, "title": "", "to": 4166911038501177767, "value": 1}, {"arrowStrikethrough": false, "color": "#FF0000", "from": 4916201938344921332, "title": "", "to": 4166911038501177767, "value": 1}, {"arrowStrikethrough": false, "color": "#FF0000", "from": 8336200709397585546, "title": "", "to": 7142029215401505166, "value": 1}]);
-
-                  nodeColors = {};
-                  allNodes = nodes.get({ returnType: "Object" });
-                  for (nodeId in allNodes) {
+                nodeColors = {};
+                allNodes = nodes.get({ returnType: "Object" });
+                for (nodeId in allNodes) {
                     nodeColors[nodeId] = allNodes[nodeId].color;
-                  }
-                  allEdges = edges.get({ returnType: "Object" });
-                  // adding nodes and edges to the graph
-                  data = {nodes: nodes, edges: edges};
-
-                  var options = {
-    "configure": {
-        "enabled": false
-    },
-    "edges": {
-        "color": {
-            "inherit": true
-        },
-        "smooth": {
-            "enabled": true,
-            "type": "dynamic"
-        }
-    },
-    "interaction": {
-        "dragNodes": true,
-        "hideEdgesOnDrag": false,
-        "hideNodesOnDrag": false
-    },
-    "physics": {
-        "enabled": true,
-        "stabilization": {
-            "enabled": true,
-            "fit": true,
-            "iterations": 1000,
-            "onlyDynamicEdges": false,
-            "updateInterval": 50
-        }
-    }
-};
-
-                  
-
-
-                  
-
-                  network = new vis.Network(container, data, options);
-
-                  
-
-                  
-
-                  
-
+                }
+                allEdges = edges.get({ returnType: "Object" });
+                // adding nodes and edges to the graph
+                data = { nodes: nodes, edges: edges };
 
-                  
+                var options = {
+                    configure: {
+                        enabled: false,
+                    },
+                    edges: {
+                        color: {
+                            inherit: true,
+                        },
+                        smooth: {
+                            enabled: true,
+                            type: "dynamic",
+                        },
+                    },
+                    interaction: {
+                        dragNodes: true,
+                        hideEdgesOnDrag: false,
+                        hideNodesOnDrag: false,
+                    },
+                    physics: {
+                        enabled: true,
+                        stabilization: {
+                            enabled: true,
+                            fit: true,
+                            iterations: 1000,
+                            onlyDynamicEdges: false,
+                            updateInterval: 50,
+                        },
+                    },
+                };
 
-                  return network;
+                network = new vis.Network(container, data, options);
 
-              }
-              drawGraph();
+                return network;
+            }
+            drawGraph();
         </script>
     </body>
-</html>
\ No newline at end of file
+</html>
diff --git a/examples/rust/Cargo.toml b/examples/rust/Cargo.toml
index f4a7622bf7..09d8c27d8b 100644
--- a/examples/rust/Cargo.toml
+++ b/examples/rust/Cargo.toml
@@ -7,7 +7,7 @@ keywords = ["graph", "temporal-graph", "temporal", "examples"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-raphtory = { workspace = true, features = ["io", "proto"] }
+raphtory = { workspace = true, features = ["io"] }
 chrono = { workspace = true }
 regex = { workspace = true }
 serde = { workspace = true }
diff --git a/examples/rust/src/bin/bench/main.rs b/examples/rust/src/bin/bench/main.rs
index ad63c92313..610098076f 100644
--- a/examples/rust/src/bin/bench/main.rs
+++ b/examples/rust/src/bin/bench/main.rs
@@ -58,10 +58,10 @@ fn main() {
         CsvLoader::new(data_dir)
             .set_delimiter("\t")
             .load_into_graph(&g, |lotr: Benchr, g: &Graph| {
-                g.add_node(1, lotr.src_id.clone(), NO_PROPS, None)
+                g.add_node(1, lotr.src_id.clone(), NO_PROPS, None, None)
                     .expect("Failed to add node");
 
-                g.add_node(1, lotr.dst_id.clone(), NO_PROPS, None)
+                g.add_node(1, lotr.dst_id.clone(), NO_PROPS, None, None)
                     .expect("Failed to add node");
 
                 g.add_edge(1, lotr.src_id.clone(), lotr.dst_id.clone(), NO_PROPS, None)
diff --git a/examples/rust/src/bin/lotr/main.rs b/examples/rust/src/bin/lotr/main.rs
index 763c828e2b..ba17548c18 100644
--- a/examples/rust/src/bin/lotr/main.rs
+++ b/examples/rust/src/bin/lotr/main.rs
@@ -61,6 +61,7 @@ fn main() {
                     lotr.src_id.clone(),
                     [("type", Prop::str("Character"))],
                     None,
+                    None,
                 )
                 .expect("Failed to add node");
 
@@ -69,6 +70,7 @@ fn main() {
                     lotr.dst_id.clone(),
                     [("type", Prop::str("Character"))],
                     None,
+                    None,
                 )
                 .expect("Failed to add node");
 
diff --git a/fast_merge/src/lib.rs b/fast_merge/src/lib.rs
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/graphql-bench/.gitignore b/graphql-bench/.gitignore
index 074e8e7140..93b8db964b 100644
--- a/graphql-bench/.gitignore
+++ b/graphql-bench/.gitignore
@@ -11,11 +11,8 @@ reports
 terraform.tfstate
 terraform.tfstate.backup
 .virtual_documents
-data/apache
 node_modules
 dist
 output.csv.gz
-output.json
+data
 
-!data/apache/master/graph.tar.xz
-!data/apache/master/.raph
diff --git a/graphql-bench/Makefile b/graphql-bench/Makefile
index ba93a7abfc..86ae38e930 100644
--- a/graphql-bench/Makefile
+++ b/graphql-bench/Makefile
@@ -4,15 +4,12 @@ CURRENT_TIME := $(shell date +"%Y-%m-%dT%H-%M-%S")
 K6_IP=$(shell terraform output k6_ip | jq -r '.')
 RAPHTORY_IP=$(shell terraform output raphtory_ip | jq -r '.')
 
-data/apache/master/graph:
-	@echo "Unzipping apache master graph"
-	@cd data/apache/master && tar -Jxf graph.tar.xz -C .
 
 build:
 	pnpm install --frozen-lockfile
 	pnpm build
 
-bench-local: data/apache/master/graph build
+bench-local: build
 	pnpm concurrently --raw --kill-others --names 'raphtory,bench' 'python server.py' 'sleep 10 && k6 run --out csv=output.csv.gz dist/bench.js' || :
 	python process-k6-output.py
 
diff --git a/graphql-bench/data/apache/master/.raph b/graphql-bench/data/apache/master/.raph
index 45297e31c6..e157c0d4f4 100644
--- a/graphql-bench/data/apache/master/.raph
+++ b/graphql-bench/data/apache/master/.raph
@@ -1 +1 @@
-{"node_count":73369,"edge_count":54654,"metadata":[["hidden",{"Bool":true}]]}
\ No newline at end of file
+{"path":"data0"}
\ No newline at end of file
diff --git a/graphql-bench/data/apache/master/data0/.meta b/graphql-bench/data/apache/master/data0/.meta
new file mode 100644
index 0000000000..61cf45fc9b
--- /dev/null
+++ b/graphql-bench/data/apache/master/data0/.meta
@@ -0,0 +1 @@
+{"path":"graph0","meta":{"node_count":52151,"edge_count":44045,"graph_type":"EventGraph","is_diskgraph":false}}
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_c/00000000.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000000.parquet
new file mode 100644
index 0000000000..2d382e300a
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000000.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_c/00000001.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000001.parquet
new file mode 100644
index 0000000000..a2babe03cf
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000001.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_c/00000002.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000002.parquet
new file mode 100644
index 0000000000..a2babe03cf
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000002.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_c/00000003.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000003.parquet
new file mode 100644
index 0000000000..a2babe03cf
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000003.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_c/00000004.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000004.parquet
new file mode 100644
index 0000000000..a2babe03cf
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000004.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_c/00000005.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000005.parquet
new file mode 100644
index 0000000000..a2babe03cf
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000005.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_c/00000006.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000006.parquet
new file mode 100644
index 0000000000..a2babe03cf
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000006.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_c/00000007.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000007.parquet
new file mode 100644
index 0000000000..a2babe03cf
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000007.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_c/00000008.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000008.parquet
new file mode 100644
index 0000000000..a2babe03cf
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000008.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_c/00000009.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000009.parquet
new file mode 100644
index 0000000000..a2babe03cf
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000009.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_c/00000010.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000010.parquet
new file mode 100644
index 0000000000..a2babe03cf
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000010.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_c/00000011.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000011.parquet
new file mode 100644
index 0000000000..a2babe03cf
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000011.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_c/00000012.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000012.parquet
new file mode 100644
index 0000000000..a2babe03cf
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000012.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_c/00000013.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000013.parquet
new file mode 100644
index 0000000000..a2babe03cf
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000013.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_c/00000014.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000014.parquet
new file mode 100644
index 0000000000..a2babe03cf
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000014.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_c/00000015.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000015.parquet
new file mode 100644
index 0000000000..a2babe03cf
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000015.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_c/00000016.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000016.parquet
new file mode 100644
index 0000000000..a2babe03cf
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000016.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_c/00000017.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000017.parquet
new file mode 100644
index 0000000000..a2babe03cf
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000017.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_c/00000018.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000018.parquet
new file mode 100644
index 0000000000..a2babe03cf
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000018.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_c/00000019.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000019.parquet
new file mode 100644
index 0000000000..a2babe03cf
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000019.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_c/00000020.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000020.parquet
new file mode 100644
index 0000000000..a2babe03cf
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000020.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_c/00000021.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000021.parquet
new file mode 100644
index 0000000000..a2babe03cf
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000021.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_c/00000022.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000022.parquet
new file mode 100644
index 0000000000..a2babe03cf
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000022.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_c/00000023.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000023.parquet
new file mode 100644
index 0000000000..a2babe03cf
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_c/00000023.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_d/00000000.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000000.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000000.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_d/00000001.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000001.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000001.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_d/00000002.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000002.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000002.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_d/00000003.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000003.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000003.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_d/00000004.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000004.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000004.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_d/00000005.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000005.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000005.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_d/00000006.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000006.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000006.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_d/00000007.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000007.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000007.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_d/00000008.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000008.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000008.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_d/00000009.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000009.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000009.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_d/00000010.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000010.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000010.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_d/00000011.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000011.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000011.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_d/00000012.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000012.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000012.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_d/00000013.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000013.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000013.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_d/00000014.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000014.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000014.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_d/00000015.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000015.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000015.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_d/00000016.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000016.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000016.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_d/00000017.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000017.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000017.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_d/00000018.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000018.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000018.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_d/00000019.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000019.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000019.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_d/00000020.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000020.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000020.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_d/00000021.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000021.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000021.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_d/00000022.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000022.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000022.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_d/00000023.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000023.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_d/00000023.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_t/00000000.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000000.parquet
new file mode 100644
index 0000000000..92711bdaa2
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000000.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_t/00000001.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000001.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000001.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_t/00000002.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000002.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000002.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_t/00000003.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000003.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000003.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_t/00000004.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000004.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000004.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_t/00000005.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000005.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000005.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_t/00000006.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000006.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000006.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_t/00000007.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000007.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000007.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_t/00000008.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000008.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000008.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_t/00000009.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000009.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000009.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_t/00000010.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000010.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000010.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_t/00000011.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000011.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000011.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_t/00000012.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000012.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000012.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_t/00000013.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000013.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000013.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_t/00000014.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000014.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000014.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_t/00000015.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000015.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000015.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_t/00000016.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000016.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000016.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_t/00000017.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000017.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000017.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_t/00000018.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000018.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000018.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_t/00000019.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000019.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000019.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_t/00000020.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000020.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000020.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_t/00000021.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000021.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000021.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_t/00000022.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000022.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000022.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/edges_t/00000023.parquet b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000023.parquet
new file mode 100644
index 0000000000..7409dad9ce
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/edges_t/00000023.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/graph_c/0.parquet b/graphql-bench/data/apache/master/data0/graph0/graph_c/0.parquet
new file mode 100644
index 0000000000..f26e4b8504
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/graph_c/0.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/graph_t/0.parquet b/graphql-bench/data/apache/master/data0/graph0/graph_t/0.parquet
new file mode 100644
index 0000000000..29ecebc21b
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/graph_t/0.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000000.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000000.parquet
new file mode 100644
index 0000000000..ef2d83af38
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000000.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000001.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000001.parquet
new file mode 100644
index 0000000000..12820f0bbb
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000001.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000002.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000002.parquet
new file mode 100644
index 0000000000..12820f0bbb
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000002.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000003.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000003.parquet
new file mode 100644
index 0000000000..12820f0bbb
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000003.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000004.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000004.parquet
new file mode 100644
index 0000000000..12820f0bbb
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000004.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000005.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000005.parquet
new file mode 100644
index 0000000000..12820f0bbb
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000005.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000006.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000006.parquet
new file mode 100644
index 0000000000..12820f0bbb
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000006.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000007.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000007.parquet
new file mode 100644
index 0000000000..12820f0bbb
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000007.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000008.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000008.parquet
new file mode 100644
index 0000000000..12820f0bbb
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000008.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000009.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000009.parquet
new file mode 100644
index 0000000000..12820f0bbb
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000009.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000010.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000010.parquet
new file mode 100644
index 0000000000..12820f0bbb
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000010.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000011.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000011.parquet
new file mode 100644
index 0000000000..12820f0bbb
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000011.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000012.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000012.parquet
new file mode 100644
index 0000000000..12820f0bbb
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000012.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000013.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000013.parquet
new file mode 100644
index 0000000000..12820f0bbb
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000013.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000014.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000014.parquet
new file mode 100644
index 0000000000..12820f0bbb
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000014.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000015.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000015.parquet
new file mode 100644
index 0000000000..12820f0bbb
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000015.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000016.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000016.parquet
new file mode 100644
index 0000000000..12820f0bbb
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000016.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000017.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000017.parquet
new file mode 100644
index 0000000000..12820f0bbb
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000017.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000018.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000018.parquet
new file mode 100644
index 0000000000..12820f0bbb
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000018.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000019.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000019.parquet
new file mode 100644
index 0000000000..12820f0bbb
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000019.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000020.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000020.parquet
new file mode 100644
index 0000000000..12820f0bbb
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000020.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000021.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000021.parquet
new file mode 100644
index 0000000000..12820f0bbb
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000021.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000022.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000022.parquet
new file mode 100644
index 0000000000..12820f0bbb
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000022.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000023.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000023.parquet
new file mode 100644
index 0000000000..12820f0bbb
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000023.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000024.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000024.parquet
new file mode 100644
index 0000000000..12820f0bbb
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000024.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000025.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000025.parquet
new file mode 100644
index 0000000000..12820f0bbb
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000025.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000026.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000026.parquet
new file mode 100644
index 0000000000..12820f0bbb
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000026.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000027.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000027.parquet
new file mode 100644
index 0000000000..12820f0bbb
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000027.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000028.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000028.parquet
new file mode 100644
index 0000000000..12820f0bbb
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000028.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000029.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000029.parquet
new file mode 100644
index 0000000000..12820f0bbb
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000029.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000030.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000030.parquet
new file mode 100644
index 0000000000..12820f0bbb
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000030.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000031.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000031.parquet
new file mode 100644
index 0000000000..12820f0bbb
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_c/00000031.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000000.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000000.parquet
new file mode 100644
index 0000000000..898adf758d
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000000.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000001.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000001.parquet
new file mode 100644
index 0000000000..e6c478f367
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000001.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000002.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000002.parquet
new file mode 100644
index 0000000000..e6c478f367
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000002.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000003.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000003.parquet
new file mode 100644
index 0000000000..e6c478f367
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000003.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000004.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000004.parquet
new file mode 100644
index 0000000000..e6c478f367
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000004.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000005.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000005.parquet
new file mode 100644
index 0000000000..e6c478f367
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000005.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000006.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000006.parquet
new file mode 100644
index 0000000000..e6c478f367
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000006.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000007.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000007.parquet
new file mode 100644
index 0000000000..e6c478f367
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000007.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000008.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000008.parquet
new file mode 100644
index 0000000000..e6c478f367
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000008.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000009.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000009.parquet
new file mode 100644
index 0000000000..e6c478f367
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000009.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000010.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000010.parquet
new file mode 100644
index 0000000000..e6c478f367
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000010.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000011.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000011.parquet
new file mode 100644
index 0000000000..e6c478f367
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000011.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000012.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000012.parquet
new file mode 100644
index 0000000000..e6c478f367
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000012.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000013.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000013.parquet
new file mode 100644
index 0000000000..e6c478f367
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000013.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000014.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000014.parquet
new file mode 100644
index 0000000000..e6c478f367
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000014.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000015.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000015.parquet
new file mode 100644
index 0000000000..e6c478f367
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000015.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000016.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000016.parquet
new file mode 100644
index 0000000000..e6c478f367
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000016.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000017.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000017.parquet
new file mode 100644
index 0000000000..e6c478f367
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000017.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000018.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000018.parquet
new file mode 100644
index 0000000000..e6c478f367
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000018.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000019.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000019.parquet
new file mode 100644
index 0000000000..e6c478f367
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000019.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000020.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000020.parquet
new file mode 100644
index 0000000000..e6c478f367
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000020.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000021.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000021.parquet
new file mode 100644
index 0000000000..e6c478f367
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000021.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000022.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000022.parquet
new file mode 100644
index 0000000000..e6c478f367
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000022.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000023.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000023.parquet
new file mode 100644
index 0000000000..e6c478f367
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000023.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000024.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000024.parquet
new file mode 100644
index 0000000000..e6c478f367
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000024.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000025.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000025.parquet
new file mode 100644
index 0000000000..e6c478f367
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000025.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000026.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000026.parquet
new file mode 100644
index 0000000000..e6c478f367
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000026.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000027.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000027.parquet
new file mode 100644
index 0000000000..e6c478f367
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000027.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000028.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000028.parquet
new file mode 100644
index 0000000000..e6c478f367
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000028.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000029.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000029.parquet
new file mode 100644
index 0000000000..e6c478f367
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000029.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000030.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000030.parquet
new file mode 100644
index 0000000000..e6c478f367
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000030.parquet differ
diff --git a/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000031.parquet b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000031.parquet
new file mode 100644
index 0000000000..e6c478f367
Binary files /dev/null and b/graphql-bench/data/apache/master/data0/graph0/nodes_t/00000031.parquet differ
diff --git a/graphql-bench/data/apache/master/graph.tar.xz b/graphql-bench/data/apache/master/graph.tar.xz
deleted file mode 100644
index 8cd640967c..0000000000
Binary files a/graphql-bench/data/apache/master/graph.tar.xz and /dev/null differ
diff --git a/graphql-bench/package.json b/graphql-bench/package.json
index 27de176967..f1b4ebbb85 100644
--- a/graphql-bench/package.json
+++ b/graphql-bench/package.json
@@ -1,35 +1,35 @@
 {
-    "name": "bench",
-    "private": true,
-    "version": "0.0.0",
-    "type": "module",
-    "module": "./dist/index.js",
-    "files": [
-        "dist"
-    ],
-    "scripts": {
-        "prebuild": "genql --schema ../raphtory-graphql/schema.graphql --output src/__generated",
-        "build": "tsc --noEmit && tsup",
-        "bench": "pnpm build && K6_WEB_DASHBOARD=true K6_WEB_DASHBOARD_EXPORT=report.html k6 run --out csv=output.csv.gz dist/bench.js"
-    },
-    "devDependencies": {
-        "@genql/cli": "^6.3.3",
-        "@types/k6": "^1.6.0",
-        "@types/node": "^25.3.5",
-        "concurrently": "^9.2.1",
-        "tsup": "8.5.1",
-        "typescript": "^5.9.3"
-    },
-    "dependencies": {
-        "@google-cloud/compute": "^6.8.0",
-        "dotenv": "^17.3.1",
-        "node-ssh": "^13.2.1",
-        "zod": "^4.3.6"
-    },
-    "pnpm": {
-        "overrides": {
-            "@tootallnate/once@<3.0.1": ">=3.0.1",
-            "undici@<6.23.0": ">=6.23.0"
-        }
+  "name": "bench",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "module": "./dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "prebuild": "genql --schema ../raphtory-graphql/schema.graphql --output src/__generated",
+    "build": "tsc --noEmit && tsup",
+    "bench": "pnpm build && K6_WEB_DASHBOARD=true K6_WEB_DASHBOARD_EXPORT=report.html k6 run --out csv=output.csv.gz dist/bench.js"
+  },
+  "devDependencies": {
+    "@genql/cli": "^6.3.3",
+    "@types/k6": "^1.6.0",
+    "@types/node": "^25.3.5",
+    "concurrently": "^9.2.1",
+    "tsup": "8.5.1",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "@google-cloud/compute": "^6.8.0",
+    "dotenv": "^17.3.1",
+    "node-ssh": "^13.2.1",
+    "zod": "^4.3.6"
+  },
+  "pnpm": {
+    "overrides": {
+      "@tootallnate/once@<3.0.1": ">=3.0.1",
+      "undici@<6.23.0": ">=6.23.0"
     }
+  }
 }
diff --git a/graphql-bench/src/bench.ts b/graphql-bench/src/bench.ts
index 5b370114b1..6ba8b222aa 100644
--- a/graphql-bench/src/bench.ts
+++ b/graphql-bench/src/bench.ts
@@ -1,252 +1,251 @@
-import { check, fail, sleep } from 'k6';
-import http from 'k6/http';
-import { Rate } from 'k6/metrics';
+import { check, fail, sleep } from "k6";
+import http from "k6/http";
+import { Rate } from "k6/metrics";
 
-import { fetchAndCheck, fetchAndParse, mutate } from './utils';
+import { fetchAndCheck, fetchAndParse, mutate } from "./utils";
 
 const TIME_RANGE = 2000 * 365 * 24 * 60 * 60 * 1000;
 const randomTime = () => Math.floor(Math.random() * TIME_RANGE);
 
-export const errorRate = new Rate('errors');
+export const errorRate = new Rate("errors");
 
 const duration = 1;
 const stagesInMinutes: { duration: number; target: number }[] = [
-    { duration, target: 100 },
-    { duration, target: 400 },
-    { duration, target: 1600 },
-    { duration, target: 6400 },
+  { duration, target: 100 },
+  { duration, target: 400 },
+  { duration, target: 1600 },
+  { duration, target: 6400 },
 ];
 
 // +1 to leave enough time for the server to recover from prev scenario
 const minutesPerScenario =
-    stagesInMinutes.map(({ duration }) => duration).reduce((a, b) => a + b) + 1;
+  stagesInMinutes.map(({ duration }) => duration).reduce((a, b) => a + b) + 1;
 
 const execs = [
-    addNode,
-    randomNodePage,
-    randomEdgePage,
-    nodePropsByName,
-    nodeNeighboursByName,
-    readAndWriteNodeProperties,
+  addNode,
+  randomNodePage,
+  randomEdgePage,
+  nodePropsByName,
+  nodeNeighboursByName,
+  readAndWriteNodeProperties,
 ];
 const scenarios = execs.map(
-    (exec, index) =>
-        [
-            exec.name,
-            {
-                executor: 'ramping-arrival-rate',
-                exec: exec.name,
-                startRate: 0,
-                startTime: `${index * minutesPerScenario}m`,
-                timeUnit: '1s',
-                preAllocatedVUs: 5,
-                maxVUs: 1000,
-                stages: stagesInMinutes.map(({ duration, target }) => ({
-                    duration: `${duration}m`,
-                    target,
-                })),
-            },
-        ] as const,
+  (exec, index) =>
+    [
+      exec.name,
+      {
+        executor: "ramping-arrival-rate",
+        exec: exec.name,
+        startRate: 0,
+        startTime: `${index * minutesPerScenario}m`,
+        timeUnit: "1s",
+        preAllocatedVUs: 5,
+        maxVUs: 1000,
+        stages: stagesInMinutes.map(({ duration, target }) => ({
+          duration: `${duration}m`,
+          target,
+        })),
+      },
+    ] as const,
 );
 
 export const options = {
-    scenarios: Object.fromEntries(scenarios),
+  scenarios: Object.fromEntries(scenarios),
 };
 
 type SetupData = {
-    graphPaths: string[];
-    countNodes: number;
-    countEdges: number;
+  graphPaths: string[];
+  countNodes: number;
+  countEdges: number;
 };
 
 export function setup(): SetupData {
-    const graphListResponse = fetchAndParse({
-        namespaces: { list: { graphs: { list: { path: true } } } },
-    });
-    const graphPaths = graphListResponse.data.namespaces.list.flatMap(
-        (ns: any) => ns.graphs.list.map((graph: any) => graph.path),
-    );
-
-    mutate({
-        newGraph: {
-            __args: {
-                path: 'empty',
-                graphType: 'EVENT',
-            },
-        },
-    });
-
-    // this is to trigger the load of the empty graph into memory
-    fetchAndCheck(errorRate, {
-        graph: {
-            __args: {
-                path: 'empty',
-            },
-            countNodes: true,
-        },
-    });
-
-    const graphResponse = fetchAndParse({
-        graph: {
-            __args: {
-                path: 'master',
-            },
-            countNodes: true,
-            countEdges: true,
-        },
-    });
-
-    return {
-        graphPaths,
-        countNodes: graphResponse.data.graph.countNodes,
-        countEdges: graphResponse.data.graph.countEdges,
-    };
+  const graphListResponse = fetchAndParse({
+    namespaces: { list: { graphs: { list: { path: true } } } },
+  });
+  const graphPaths = graphListResponse.data.namespaces.list.flatMap((ns: any) =>
+    ns.graphs.list.map((graph: any) => graph.path),
+  );
+
+  mutate({
+    newGraph: {
+      __args: {
+        path: "empty",
+        graphType: "EVENT",
+      },
+    },
+  });
+
+  // this is to trigger the load of the empty graph into memory
+  fetchAndCheck(errorRate, {
+    graph: {
+      __args: {
+        path: "empty",
+      },
+      countNodes: true,
+    },
+  });
+
+  const graphResponse = fetchAndParse({
+    graph: {
+      __args: {
+        path: "master",
+      },
+      countNodes: true,
+      countEdges: true,
+    },
+  });
+
+  return {
+    graphPaths,
+    countNodes: graphResponse.data.graph.countNodes,
+    countEdges: graphResponse.data.graph.countEdges,
+  };
 }
 
-
-
 export function addNode() {
-    const name = Math.random().toString();
-    const time = randomTime();
-    fetchAndCheck(errorRate, {
-        updateGraph: {
-            __args: {
-                path: 'empty',
-            },
-            addNode: {
-                __args: {
-                    name,
-                    time,
-                },
-                success: true,
-            },
+  const name = Math.random().toString();
+  const time = randomTime();
+  fetchAndCheck(errorRate, {
+    updateGraph: {
+      __args: {
+        path: "empty",
+      },
+      addNode: {
+        __args: {
+          name,
+          time,
         },
-    });
+        success: true,
+      },
+    },
+  });
 }
 
 export function randomNodePage(input: SetupData) {
-    const offset = Math.floor(Math.random() * (input.countNodes - 20));
-    fetchAndCheck(errorRate, {
-        graph: {
-            __args: { path: 'master' },
-            nodes: {
-                page: {
-                    __args: { offset, limit: 20 },
-                    degree: true,
-                    name: true,
-                },
-            },
+  const offset = Math.floor(Math.random() * (input.countNodes - 20));
+  fetchAndCheck(errorRate, {
+    graph: {
+      __args: { path: "master" },
+      nodes: {
+        page: {
+          __args: { offset, limit: 20 },
+          degree: true,
+          name: true,
         },
-    });
+      },
+    },
+  });
 }
 
 export function randomEdgePage(input: SetupData) {
   const offset = Math.floor(Math.random() * (input.countEdges - 20));
-    fetchAndCheck(errorRate, {
-        graph: {
-            __args: { path: 'master' },
-            edges: {
-                page: {
-                    __args: { offset, limit: 20 },
-                    explodeLayers: {
-                        count: true,
-                    },
-                    history: {
-                        list: {
-                            timestamp: true,
-                        },
-                    },
-                    src: { name: true },
-                    dst: { name: true },
-                },
+  fetchAndCheck(errorRate, {
+    graph: {
+      __args: { path: "master" },
+      edges: {
+        page: {
+          __args: { offset, limit: 20 },
+          explodeLayers: {
+            count: true,
+          },
+          history: {
+            list: {
+              timestamp: true,
             },
+          },
+          src: { name: true },
+          dst: { name: true },
         },
-    });
+      },
+    },
+  });
 }
 
 export function nodePropsByName() {
-    fetchAndCheck(errorRate, {
-        graph: {
-            __args: { path: 'master' },
-            node: {
-                __args: {
-                    name: 'SPARK-22386',
-                },
-                metadata: {
-                    values: {
-                        key: true,
-                        value: true,
-                    },
-                },
-            },
+  fetchAndCheck(errorRate, {
+    graph: {
+      __args: { path: "master" },
+      node: {
+        __args: {
+          name: "SPARK-22386",
         },
-    });
+        metadata: {
+          values: {
+            key: true,
+            value: true,
+          },
+        },
+      },
+    },
+  });
 }
 
 export function nodeNeighboursByName() {
-    fetchAndCheck(errorRate, {
-        graph: {
-            __args: { path: 'master' },
-            node: {
-                __args: {
-                    name: 'SPARK-22386',
-                },
-                neighbours: {
-                    list: {
-                        name: true,
-                    },
-                },
-            },
+  fetchAndCheck(errorRate, {
+    graph: {
+      __args: { path: "master" },
+      node: {
+        __args: {
+          name: "SPARK-22386",
         },
-    });
+        neighbours: {
+          list: {
+            name: true,
+          },
+        },
+      },
+    },
+  });
 }
 
-
 export function readAndWriteNodeProperties(input: SetupData) {
-    const random = Math.random();
-    const time = randomTime();
-    if (random < 0.3) {
-      fetchAndCheck(errorRate, {
-          updateGraph: {
-              __args: {
-                  path: 'master',
-              },
-              node: {
+  const random = Math.random();
+  const time = randomTime();
+  if (random < 0.3) {
+    fetchAndCheck(errorRate, {
+      updateGraph: {
+        __args: {
+          path: "master",
+        },
+        node: {
+          __args: {
+            name: "SPARK-22386",
+          },
+          addUpdates: {
+            __args: {
+              time,
+              properties: [
+                { key: "temporal_bool", value: { bool: Math.random() > 0.5 } },
+              ],
+            },
+          },
+        },
+      },
+    });
+  } else {
+    fetchAndCheck(errorRate, {
+      graph: {
+        __args: { path: "master" },
+        node: {
+          __args: {
+            name: "SPARK-22386",
+          },
+          at: {
+            __args: {
+              time: { simpleTime: time },
+            },
+            properties: {
+              get: {
                 __args: {
-                  name: "SPARK-22386"
+                  key: "temporal_bool",
                 },
-                addUpdates: {
-                  __args: {
-                    time,
-                    properties: [{key: "temporal_bool", value: {bool: Math.random() > 0.5}}]
-                  }
-                }
-              }
-
-          },
-      });
-    } else {
-      fetchAndCheck(errorRate, {
-          graph: {
-              __args: { path: 'master' },
-              node: {
-                  __args: {
-                      name: 'SPARK-22386',
-                  },
-                  at: {
-                    __args: {
-                      time: { simpleTime: time },
-                    },
-                    properties: {
-                      get: {
-                        __args: {
-                          key: "temporal_bool"
-                        }
-                      }
-                    }
-                  }
+                value: true,
               },
+            },
           },
-      });
-    }
+        },
+      },
+    });
+  }
 }
diff --git a/graphql-bench/src/utils.ts b/graphql-bench/src/utils.ts
index 248ed3857b..3b98b20855 100644
--- a/graphql-bench/src/utils.ts
+++ b/graphql-bench/src/utils.ts
@@ -1,67 +1,77 @@
 import http, { RefinedResponse } from "k6/http";
-import { generateMutationOp, generateQueryOp, MutRootGenqlSelection, QueryRootGenqlSelection } from "./__generated";
+import {
+  generateMutationOp,
+  generateQueryOp,
+  MutRootGenqlSelection,
+  QueryRootGenqlSelection,
+} from "./__generated";
 import { Rate } from "k6/metrics";
 import { check, fail } from "k6";
 
-const URL = __ENV.RAPHTORY_URL ?? 'http://localhost:1736';
+const URL = __ENV.RAPHTORY_URL ?? "http://localhost:1736";
 
-function checkResponse<RT extends "binary" | "none" | "text"| undefined>(response: RefinedResponse<RT>, errorRate: Rate) {
+function checkResponse<RT extends "binary" | "none" | "text" | undefined>(
+  response: RefinedResponse<RT>,
+  errorRate: Rate,
+) {
   const result = check(response, {
-      'response status is 200': (r) => r.status === 200,
-      'response has data field defined': (r) => {
-          if (typeof r.body === 'string') {
-              const body = JSON.parse(r.body);
-              const result = 'data' in body &&
-                body.data !== undefined &&
-                body.data !== null; // FIXME: improve query checking, I wish I could just rely on genql
+    "response status is 200": (r) => r.status === 200,
+    "response has data field defined": (r) => {
+      if (typeof r.body === "string") {
+        const body = JSON.parse(r.body);
+        const result =
+          "data" in body && body.data !== undefined && body.data !== null; // FIXME: improve query checking, I wish I could just rely on genql
 
-              if (result === false) {
-                // console.log(">>> error:", JSON.stringify(body, null, 2));
-                // console.log(">>> request:", JSON.stringify(response.request.body, null, 2))
-              }
+        if (result === false) {
+          console.log(">>> error:", JSON.stringify(body, null, 2));
+          console.log(
+            ">>> request:",
+            JSON.stringify(response.request.body, null, 2),
+          );
+        }
 
-              return result;
-          } else {
-              return false;
-          }
-      },
+        return result;
+      } else {
+        return false;
+      }
+    },
   });
   errorRate.add(!result);
 }
 
 const params = {
-    headers: { 'Content-Type': 'application/json', 'Accept-Encoding': 'gzip' },
+  headers: { "Content-Type": "application/json", "Accept-Encoding": "gzip" },
 };
 function fetch(query: QueryRootGenqlSelection) {
-    const { query: compiledQuery, variables } = generateQueryOp(query);
-    const payload = JSON.stringify({
-        query: compiledQuery,
-        variables: variables,
-    });
-    return http.post(URL, payload, params);
+  const { query: compiledQuery, variables } = generateQueryOp(query);
+  const payload = JSON.stringify({
+    query: compiledQuery,
+    variables: variables,
+  });
+  return http.post(URL, payload, params);
 }
 
 export function mutate(query: MutRootGenqlSelection) {
-    const { query: compiledQuery, variables } = generateMutationOp(query);
-    const payload = JSON.stringify({
-        query: compiledQuery,
-        variables: variables,
-    });
-    return http.post(URL, payload, params);
+  const { query: compiledQuery, variables } = generateMutationOp(query);
+  const payload = JSON.stringify({
+    query: compiledQuery,
+    variables: variables,
+  });
+  return http.post(URL, payload, params);
 }
 
 export function fetchAndParse(query: QueryRootGenqlSelection) {
-    const response = fetch(query);
-    if (typeof response.body !== 'string') {
-        fail(JSON.stringify(response));
-    }
-    return JSON.parse(response.body);
+  const response = fetch(query);
+  if (typeof response.body !== "string") {
+    fail(JSON.stringify(response));
+  }
+  return JSON.parse(response.body);
 }
 
-export function fetchAndCheck(errorRate: Rate, query: QueryRootGenqlSelection, ) {
-    checkResponse(fetch(query), errorRate);
+export function fetchAndCheck(errorRate: Rate, query: QueryRootGenqlSelection) {
+  checkResponse(fetch(query), errorRate);
 }
 
-export function mutateAndCheck(errorRate: Rate, query: MutRootGenqlSelection, ) {
-    checkResponse(mutate(query), errorRate);
+export function mutateAndCheck(errorRate: Rate, query: MutRootGenqlSelection) {
+  checkResponse(mutate(query), errorRate);
 }
diff --git a/optd b/optd
new file mode 160000
index 0000000000..c8a444e100
--- /dev/null
+++ b/optd
@@ -0,0 +1 @@
+Subproject commit c8a444e1000ecd3b3f366f52a970b6495ec6a591
diff --git a/pometry-storage-private b/pometry-storage-private
deleted file mode 160000
index f28bd721ea..0000000000
--- a/pometry-storage-private
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit f28bd721ea91a59f80f08af3d760a33725eca481
diff --git a/pometry-storage/src/lib.rs b/pometry-storage/src/lib.rs
deleted file mode 100644
index 0851e257e4..0000000000
--- a/pometry-storage/src/lib.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-#[cfg(feature = "storage")]
-compile_error!("The 'storage' feature is private");
diff --git a/python/.github/workflows/CI.yml b/python/.github/workflows/CI.yml
index b34789d3ca..e345c23a21 100644
--- a/python/.github/workflows/CI.yml
+++ b/python/.github/workflows/CI.yml
@@ -11,7 +11,10 @@ jobs:
   linux:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v5
+      with:
+        submodules: recursive
+        token: '${{ secrets.PULL_TOKEN }}'
     - uses: messense/maturin-action@v1
       with:
         manylinux: auto
@@ -26,7 +29,10 @@ jobs:
   windows:
     runs-on: windows-latest
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v5
+      with:
+        submodules: recursive
+        token: '${{ secrets.PULL_TOKEN }}'
     - uses: messense/maturin-action@v1
       with:
         command: build
@@ -40,7 +46,10 @@ jobs:
   macos:
     runs-on: macos-latest
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v5
+      with:
+        submodules: recursive
+        token: '${{ secrets.PULL_TOKEN }}'
     - uses: messense/maturin-action@v1
       with:
         command: build
diff --git a/python/Cargo.toml b/python/Cargo.toml
index 7f7c77b0b3..2744f7afdc 100644
--- a/python/Cargo.toml
+++ b/python/Cargo.toml
@@ -21,17 +21,23 @@ crate-type = ["cdylib"]
 pyo3 = { workspace = true }
 raphtory = { workspace = true, features = [
     "python",
-    "search",
     "vectors",
-    "proto",
 ] }
 raphtory-graphql = { workspace = true, features = [
-    "python", "search"
+    "python",
 ] }
+auth = { workspace = true }
+clam-core = { workspace = true, features = ["python"] }
+
 
 [features]
-storage = ["raphtory/storage", "raphtory-graphql/storage"]
 extension-module = ["pyo3/extension-module"]
+search = ["raphtory/search", "raphtory-graphql/search"]
+proto = ["raphtory/proto"]
+
 
 [build-dependencies]
 pyo3-build-config = { workspace = true }
+
+#[target.'cfg(not(target_env = "msvc"))'.dependencies]
+#tikv-jemallocator.workspace = true
diff --git a/python/profile.json b/python/profile.json
deleted file mode 100644
index 6b806a3cfc..0000000000
--- a/python/profile.json
+++ /dev/null
@@ -1 +0,0 @@
-{"meta":{"categories":[{"name":"Other","color":"grey","subcategories":["Other"]},{"name":"Regular","color":"blue","subcategories":["Other"]}],"debug":false,"extensions":{"baseURL":[],"id":[],"length":0,"name":[]},"interval":1.0,"preprocessedProfileVersion":44,"processType":0,"product":"python","sampleUnits":{"eventDelay":"ms","threadCPUDelta":"µs","time":"ms"},"startTime":1708001452023.772,"symbolicated":false,"pausedRanges":[],"version":24,"usesOnlyOneStackType":true,"doesNotUseFrameImplementation":true,"sourceCodeIsNotOnSearchfox":true,"markerSchema":[]},"libs":[{"name":"libdyld.dylib","path":"/usr/lib/system/libdyld.dylib","debugName":"libdyld.dylib","debugPath":"/usr/lib/system/libdyld.dylib","breakpadId":"11007DE4ABE13079BF1C4D0EADA884DD0","codeId":null,"arch":"x86_64"},{"name":"python","path":"/Users/bensteer/miniconda3/envs/raphtory/bin/python","debugName":"python","debugPath":"/Users/bensteer/miniconda3/envs/raphtory/bin/python","breakpadId":"6998F14EBF303B7B9B5424A3CF365B400","codeId":null,"arch":"x86_64"},{"name":"dyld","path":"/usr/lib/dyld","debugName":"dyld","debugPath":"/usr/lib/dyld","breakpadId":"57DB2053BFD5368397C6F1DB2A1F1D090","codeId":null,"arch":"x86_64"},{"name":"libsystem_c.dylib","path":"/usr/lib/system/libsystem_c.dylib","debugName":"libsystem_c.dylib","debugPath":"/usr/lib/system/libsystem_c.dylib","breakpadId":"337F746F82323439BBFFBAB9C10731F40","codeId":null,"arch":"x86_64"},{"name":"libsystem_notify.dylib","path":"/usr/lib/system/libsystem_notify.dylib","debugName":"libsystem_notify.dylib","debugPath":"/usr/lib/system/libsystem_notify.dylib","breakpadId":"1AE2715689B53E4AAB14A77E91F93DC70","codeId":null,"arch":"x86_64"},{"name":"libsystem_kernel.dylib","path":"/usr/lib/system/libsystem_kernel.dylib","debugName":"libsystem_kernel.dylib","debugPath":"/usr/lib/system/libsystem_kernel.dylib","breakpadId":"B51DEA59126035C6B7B6AA6D8459ECEC0","codeId":null,"arch":"x86_64"},{"name":"libsystem_platform.dylib","path":"/usr/lib/system/libsystem_platform.dylib","debugName":"libsystem_platform.dylib","debugPath":"/usr/lib/system/libsystem_platform.dylib","breakpadId":"6F368391D41B3A7E99926000FA985F210","codeId":null,"arch":"x86_64"}],"threads":[{"frameTable":{"length":154,"address":[-1,89916,8695,2512997,2513518,2306561,2350515,3960831,85029,85223,21834,160704,146794,146136,86202,117384,117246,143407,103226,2306876,2308365,3402529,520245,1331795,1138526,2297380,2312544,599776,2306969,2323558,2231968,1638361,1638972,1877642,2323606,2324390,487603,462427,473246,1819633,2185661,490769,491270,1887990,887326,1619066,1611214,462818,464257,1033828,1040005,2324485,2180328,485106,1612976,1916830,886643,2203864,902487,2915125,2916116,339206,331565,333132,4835,5675,4794,2323717,1402420,1403274,1960942,1949965,1909745,2552401,2608845,10182,2183685,1960845,471759,1037879,1052768,5360,2323907,2328104,1611149,1888404,1052686,941933,1750820,2687434,600192,488369,486420,2685192,487358,486703,1033881,2697385,40769,6994,1619279,2373863,2365030,2557744,172990,172784,10566,1869235,551413,2747814,2767391,2769490,489926,547947,2725698,2733827,546572,2699770,2502081,7374,1882321,1042232,1908337,2274430,2263903,2265312,2264916,1027880,2525824,942819,1042136,1065529,827894,1073718,1918701,884179,1064889,1039598,1659261,2508046,2334173,2524463,2519427,2334181,2339454,2522933,1037374,794164,631834,499788,1017564,2334280,2342089,2351585],"inlineDepth":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"category":[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],"subcategory":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"func":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153],"nativeSymbol":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null],"innerWindowID":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null],"implementation":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null],"line":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null],"column":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null],"optimizations":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null]},"funcTable":{"length":154,"name":[0,2,4,5,6,7,8,9,10,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,65,66,67,69,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160],"isJS":[false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false],"relevantForJS":[false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false],"resource":[-1,0,1,1,1,1,1,1,0,0,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,3,3,4,5,5,1,1,1,1,1,1,1,1,5,1,1,1,1,1,6,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5,1,1,1,1,3,3,5,1,1,1,1,1,1,1,1,1,1,1,1,5,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],"fileName":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null],"lineNumber":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null],"columnNumber":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null]},"markers":{"length":0,"category":[],"data":[],"endTime":[],"name":[],"phase":[],"startTime":[]},"name":"GeckoMain","nativeSymbols":{"length":0,"address":[],"functionSize":[],"libIndex":[],"name":[]},"pausedRanges":[],"pid":72023,"processName":"python","processShutdownTime":206.111497,"processStartupTime":178.281462,"processType":"default","registerTime":178.281462,"resourceTable":{"length":7,"lib":[0,1,2,3,4,5,6],"name":[1,3,12,64,68,70,87],"host":[null,null,null,null,null,null,null],"type":[1,1,1,1,1,1,1]},"samples":{"length":25,"stack":[18,25,27,33,56,89,107,130,155,200,201,215,234,248,271,294,317,336,350,361,248,362,366,374,378],"time":[178.880918,181.882413,183.164704,184.068305,185.09071,186.054176,186.898257,188.165488,189.072589,190.109677,191.106161,192.113115,193.148543,194.083976,195.080671,195.927909,197.13454,197.989232,199.156562,200.114017,201.110151,202.107345,203.075021,203.952698,205.139406],"weight":[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],"weightType":"samples","threadCPUDelta":[5439,98,1270,881,994,605,746,1232,813,962,957,973,896,930,914,689,1152,837,1137,847,1024,987,876,795,1053]},"stackTable":{"length":379,"prefix":[null,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,4,19,20,21,22,23,24,19,26,4,28,29,30,31,32,28,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,34,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,28,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,103,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,92,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,28,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,171,171,202,203,204,205,206,207,208,209,210,211,212,213,214,203,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,171,235,236,237,238,239,240,241,242,243,244,245,246,247,171,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,270,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,262,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,304,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,328,337,338,339,340,341,342,343,344,345,346,347,348,349,322,351,352,353,354,355,356,357,358,359,360,177,2,363,364,365,363,367,368,369,370,371,372,373,363,375,376,377],"frame":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,37,38,43,44,45,31,32,43,44,46,47,48,49,50,51,52,53,44,54,40,41,42,37,38,43,44,45,31,32,39,40,41,42,37,38,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,52,53,44,54,40,41,42,37,38,72,73,74,75,55,44,45,31,32,39,76,41,42,37,38,55,44,54,40,41,42,37,38,72,73,74,75,77,78,38,43,44,54,40,41,42,37,38,55,44,45,31,32,43,44,46,47,48,49,79,80,81,82,83,52,53,44,54,40,41,42,37,38,43,44,45,31,32,39,40,41,42,37,38,43,44,45,31,32,39,40,41,42,37,38,72,45,31,32,43,44,84,32,85,49,86,87,88,43,44,89,90,91,92,44,93,94,95,96,97,98,99,100,101,102,31,32,43,44,54,40,41,42,37,38,43,44,103,104,105,106,107,108,109,110,111,112,113,114,115,112,116,117,118,119,72,100,101,102,31,32,43,44,54,40,41,42,37,38,55,44,54,40,41,42,37,38,120,55,44,45,31,32,39,40,41,42,37,38,55,44,45,31,32,43,44,46,47,48,49,121,72,45,31,32,39,40,41,42,37,38,72,89,90,91,92,44,93,94,95,96,97,98,99,55,44,45,31,32,39,40,41,42,37,38,122,123,124,125,126,127,128,129,55,44,45,31,32,43,44,46,47,48,49,130,131,132,43,44,46,48,49,133,38,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,142],"category":[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],"subcategory":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]},"stringArray":["0x1","libdyld.dylib","0x15f3c","python","0x21f7","0x265865","0x265a6e","0x233201","0x23ddb3","0x3c6fff","0x14c25","0x14ce7","dyld","0x554a","0x273c0","0x23d6a","0x23ad8","0x150ba","0x1ca88","0x1c9fe","0x2302f","0x1933a","0x23333c","0x23390d","0x33eb21","0x7f035","0x145253","0x115f5e","0x230e24","0x234960","0x926e0","0x233399","0x237466","0x220ea0","0x18ffd9","0x19023c","0x1ca68a","0x237496","0x2377a6","0x770b3","0x70e5b","0x7389e","0x1bc3f1","0x2159bd","0x77d11","0x77f06","0x1ccef6","0xd8a1e","0x18b47a","0x1895ce","0x70fe2","0x71581","0xfc664","0xfde85","0x237805","0x2144e8","0x766f2","0x189cb0","0x1d3f9e","0xd8773","0x21a0d8","0xdc557","0x2c7b35","0x2c7f14","libsystem_c.dylib","0x52d06","0x50f2d","0x5154c","libsystem_notify.dylib","0x12e3","libsystem_kernel.dylib","0x162b","0x12ba","0x237505","0x156634","0x15698a","0x1debee","0x1dc10d","0x1d23f1","0x26f251","0x27cecd","0x27c6","0x215205","0x1deb8d","0x732cf","0xfd637","0x101060","libsystem_platform.dylib","0x14f0","0x2375c3","0x238628","0x18958d","0x1cd094","0x10100e","0xe5f6d","0x1ab724","0x2901ca","0x92880","0x773b1","0x76c14","0x28f908","0x76fbe","0x76d2f","0xfc699","0x2928a9","0x9f41","0x1b52","0x18b54f","0x2438e7","0x241666","0x270730","0x2a3be","0x2a2f0","0x2946","0x1c85b3","0x869f5","0x29eda6","0x2a3a1f","0x2a4252","0x779c6","0x85c6b","0x299742","0x29b703","0x8570c","0x2931fa","0x262dc1","0x1cce","0x1cb8d1","0xfe738","0x1d1e71","0x22b47e","0x228b5f","0x2290e0","0x228f54","0xfaf28","0x268a80","0xe62e3","0xfe6d8","0x104239","0xca1f6","0x106236","0x1d46ed","0xd7dd3","0x103fb9","0xfdcee","0x19517d","0x26450e","0x239ddd","0x26852f","0x267183","0x239de5","0x23b27e","0x267f35","0xfd43e","0xc1e34","0x9a41a","0x7a04c","0xf86dc","0x239e48","0x23bcc9","0x23e1e1"],"tid":512579,"unregisterTime":206.111497}],"pages":[],"profilerOverhead":[],"counters":[]}
\ No newline at end of file
diff --git a/python/python/raphtory/__init__.py b/python/python/raphtory/__init__.py
index 51fa280a9a..2b26bda251 100644
--- a/python/python/raphtory/__init__.py
+++ b/python/python/raphtory/__init__.py
@@ -8,6 +8,8 @@
 _sys.modules["raphtory.vectors"] = vectors
 _sys.modules["raphtory.graphql"] = graphql
 _sys.modules["raphtory.filter"] = filter
+_sys.modules["raphtory.gql"] = gql
+_sys.modules["raphtory.iterables"] = iterables
 
 __doc__ = _raphtory.__doc__
 if hasattr(_raphtory, "__all__"):
diff --git a/python/python/raphtory/__init__.pyi b/python/python/raphtory/__init__.pyi
index 1e1dec4822..6947ce3941 100644
--- a/python/python/raphtory/__init__.pyi
+++ b/python/python/raphtory/__init__.pyi
@@ -19,13 +19,17 @@ from raphtory.algorithms import *
 from raphtory.vectors import *
 from raphtory.node_state import *
 from raphtory.graphql import *
+from raphtory.gql import *
 from raphtory.typing import *
 import numpy as np
 from numpy.typing import NDArray
 from datetime import datetime
+import pandas
 from pandas import DataFrame
+import pyarrow  # type: ignore[import-untyped]
 from pyarrow import DataType  # type: ignore[import-untyped]
 from os import PathLike
+from decimal import Decimal
 import networkx as nx  # type: ignore
 import pyvis  # type: ignore
 from raphtory.iterables import *
@@ -59,8 +63,6 @@ __all__ = [
     "HistoryEventId",
     "Intervals",
     "WindowSet",
-    "IndexSpecBuilder",
-    "IndexSpec",
     "Prop",
     "version",
     "graphql",
@@ -71,6 +73,7 @@ __all__ = [
     "node_state",
     "filter",
     "iterables",
+    "gql",
     "nullmodels",
     "plottingutils",
 ]
@@ -317,14 +320,6 @@ class GraphView(object):
            list[Node]: the nodes that match the properties name and value
         """
 
-    def get_index_spec(self) -> IndexSpec:
-        """
-        Get index spec
-
-        Returns:
-            IndexSpec:
-        """
-
     def has_edge(self, src: NodeInput, dst: NodeInput) -> bool:
         """
         Returns true if the graph contains the specified edge
@@ -402,12 +397,24 @@ class GraphView(object):
 
     def materialize(self) -> GraphView:
         """
-        Returns a 'materialized' clone of the graph view - i.e. a new graph with a copy of the data seen within the view instead of just a mask over the original graph
+        Returns a 'materialized' clone of the graph view - i.e. a new graph with a
+        copy of the data seen within the view instead of just a mask over the original graph.
 
         Returns:
            GraphView: Returns a graph clone
         """
 
+    def materialize_at(self, path: str | PathLike) -> GraphView:
+        """
+        Materializes the graph view into a folder on disk.
+
+        Arguments:
+            path (str | PathLike): destination folder for the materialised graph.
+
+        Returns:
+            GraphView: the materialised graph at `path`.
+        """
+
     @property
     def metadata(self) -> Metadata:
         """
@@ -477,32 +484,6 @@ class GraphView(object):
             WindowSet: A `WindowSet` object.
         """
 
-    def search_edges(self, filter: Any, limit: int = 25, offset: int = 0) -> list[Edge]:
-        """
-        Searches for edges which match the given filter expression. This uses Tantivy's exact search.
-
-        Arguments:
-           filter: The filter expression to search for.
-           limit(int): The maximum number of results to return. Defaults to 25.
-           offset(int): The number of results to skip. This is useful for pagination. Defaults to 0.
-
-        Returns:
-           list[Edge]: A list of edges which match the filter expression. The list will be empty if no edges match the query.
-        """
-
-    def search_nodes(self, filter: Any, limit: int = 25, offset: int = 0) -> list[Node]:
-        """
-        Searches for nodes which match the given filter expression. This uses Tantivy's exact search.
-
-        Arguments:
-           filter: The filter expression to search for.
-           limit(int): The maximum number of results to return. Defaults to 25.
-           offset(int): The number of results to skip. This is useful for pagination. Defaults to 0.
-
-        Returns:
-           list[Node]: A list of nodes which match the filter expression. The list will be empty if no nodes match.
-        """
-
     def shrink_end(self, end: TimeInput) -> GraphView:
         """
         Set the end of the window to the smaller of `end` and `self.end()`
@@ -691,7 +672,7 @@ class GraphView(object):
 
     def vectorise(
         self,
-        model,
+        model: VectorCache,
         nodes: bool | str = True,
         edges: bool | str = True,
         verbose: bool = False,
@@ -700,10 +681,9 @@ class GraphView(object):
         Create a VectorisedGraph from the current graph.
 
         Args:
-          embedding (Callable[[list], list]): Specify the embedding function used to vectorise documents into embeddings.
+          model (VectorCache): Cache wrapping the embedding model used to embed documents.
           nodes (bool | str): Enable for nodes to be embedded, disable for nodes to not be embedded or specify a custom document property to use if a string is provided. Defaults to True.
           edges (bool | str): Enable for edges to be embedded, disable for edges to not be embedded or specify a custom document property to use if a string is provided. Defaults to True.
-          cache (str, optional): Path used to store the cache of embeddings.
           verbose (bool): Enable to print logs reporting progress. Defaults to False.
 
         Returns:
@@ -736,10 +716,13 @@ class Graph(GraphView):
     A temporal graph with event semantics.
 
     Arguments:
-        num_shards (int, optional): The number of locks to use in the storage to allow for multithreaded updates.
+        path (str | PathLike, optional): The path for persisting the graph (only works with disk storage enabled)
+        config (Config, optional): The configuration options for the graph
     """
 
-    def __new__(cls, num_shards: Optional[int] = None) -> Graph:
+    def __new__(
+        cls, path: Optional[str | PathLike] = None, config: Optional[Config] = None
+    ) -> Graph:
         """Create and return a new object.  See help(type) for accurate signature."""
 
     def __reduce__(self): ...
@@ -791,6 +774,7 @@ class Graph(GraphView):
         properties: Optional[PropInput] = None,
         node_type: Optional[str] = None,
         event_id: Optional[int] = None,
+        layer: Optional[str] = None,
     ) -> MutableNode:
         """
         Adds a new node with the given id and properties to the graph.
@@ -801,6 +785,7 @@ class Graph(GraphView):
            properties (PropInput, optional): The properties of the node.
            node_type (str, optional): The optional string which will be used as a node type.
            event_id (int, optional): The optional integer which will be used as an event id.
+           layer (str, optional): The optional string which will be used as a node layer.
 
         Returns:
             MutableNode: The added node.
@@ -830,67 +815,6 @@ class Graph(GraphView):
             GraphError: If the operation fails.
         """
 
-    def cache(self, path: str) -> None:
-        """
-         Write Graph to cache file and initialise the cache.
-
-        Future updates are tracked. Use `write_updates` to persist them to the
-        cache file. If the file already exists its contents are overwritten.
-
-        Arguments:
-            path (str): The path to the cache file
-
-        Returns:
-            None:
-        """
-
-    def create_index(self) -> None:
-        """
-        Create graph index
-
-        Returns:
-            None:
-        """
-
-    def create_index_in_ram(self) -> None:
-        """
-        Creates a graph index in memory (RAM).
-
-        This is primarily intended for use in tests and should not be used in production environments,
-        as the index will not be persisted to disk.
-
-        Returns:
-            None:
-        """
-
-    def create_index_in_ram_with_spec(self, py_spec: IndexSpec) -> None:
-        """
-        Creates a graph index in memory (RAM) with the provided index spec.
-
-        This is primarily intended for use in tests and should not be used in production environments,
-        as the index will not be persisted to disk.
-
-        Arguments:
-            py_spec: The specification for the in-memory index to be created.
-
-        Arguments:
-            py_spec (IndexSpec): - The specification for the in-memory index to be created.
-
-        Returns:
-            None:
-        """
-
-    def create_index_with_spec(self, py_spec: Any) -> None:
-        """
-        Create graph index with the provided index spec.
-
-        Arguments:
-            py_spec: - The specification for the in-memory index to be created.
-
-        Returns:
-            None:
-        """
-
     def create_node(
         self,
         timestamp: TimeInput,
@@ -898,6 +822,7 @@ class Graph(GraphView):
         properties: Optional[PropInput] = None,
         node_type: Optional[str] = None,
         event_id: Optional[int] = None,
+        layer: Optional[str] = None,
     ) -> MutableNode:
         """
         Creates a new node with the given id and properties to the graph. It fails if the node already exists.
@@ -908,7 +833,7 @@ class Graph(GraphView):
            properties (PropInput, optional): The properties of the node.
            node_type (str, optional): The optional string which will be used as a node type.
            event_id (int, optional): The optional integer which will be used as an event id.
-
+           layer (str, optional): The optional string which will be used as a layer.
         Returns:
             MutableNode: The created node.
 
@@ -973,6 +898,14 @@ class Graph(GraphView):
             Graph: the graph with event semantics applied
         """
 
+    def flush(self) -> None:
+        """
+        Trigger a flush of the underlying storage if disk storage is enabled
+
+        Returns:
+            None: This function does not return a value, if the operation is successful.
+        """
+
     @staticmethod
     def from_parquet(graph_dir: str | PathLike) -> Graph:
         """
@@ -1153,18 +1086,17 @@ class Graph(GraphView):
         """
 
     @staticmethod
-    def load_cached(path: str) -> Graph:
+    def load(path: str | PathLike, config: Optional[Config] = None) -> Graph:
         """
-         Load Graph from a file and initialise it as a cache file.
-
-        Future updates are tracked. Use `write_updates` to persist them to the
-        cache file.
+        Load a disk graph from path
 
         Arguments:
-          path (str): The path to the cache file
+            path (str | PathLike): the path of the graph folder
+            config (Config, optional): specify a new config to override the values saved for the graph
+                                       (note that the page sizes cannot be overridden and are ignored)
 
         Returns:
-           Graph: the loaded graph with initialised cache
+            Graph: the graph
         """
 
     def load_edge_metadata(
@@ -1222,6 +1154,7 @@ class Graph(GraphView):
             | dict[str, DataType | PropType | str]
         ] = None,
         csv_options: Optional[dict[str, str | bool]] = None,
+        event_id: Optional[str] = None,
     ) -> None:
         """
         Load edges into the graph from any data source that supports the ArrowStreamExportable protocol (by providing an __arrow_c_stream__() method),
@@ -1241,6 +1174,7 @@ class Graph(GraphView):
             layer_col (str, optional): The edge layer column name in a dataframe. Cannot be used in combination with layer. Defaults to None.
             schema (list[tuple[str, DataType | PropType | str]] | dict[str, DataType | PropType | str], optional): A list of (column_name, column_type) tuples or dict of {"column_name": column_type} to cast columns to. Defaults to None.
             csv_options (dict[str, str | bool], optional): A dictionary of CSV reading options such as delimiter, comment, escape, quote, and terminator characters, as well as allow_truncated_rows and has_header flags. Defaults to None.
+            event_id (str, optional): The column name for the secondary index. Defaults to None.
 
         Returns:
             None: This function does not return a value if the operation is successful.
@@ -1252,7 +1186,7 @@ class Graph(GraphView):
     @staticmethod
     def load_from_file(path: str) -> Graph:
         """
-         Load Graph from a file.
+         Load Graph from a parquet file.
 
         Arguments:
           path (str): The path to the file.
@@ -1313,6 +1247,9 @@ class Graph(GraphView):
             | dict[str, DataType | PropType | str]
         ] = None,
         csv_options: Optional[dict[str, str | bool]] = None,
+        event_id: Optional[str] = None,
+        layer: Optional[str] = None,
+        layer_col: Optional[str] = None,
     ) -> None:
         """
         Load nodes into the graph from any data source that supports the ArrowStreamExportable protocol (by providing an __arrow_c_stream__() method),
@@ -1331,6 +1268,9 @@ class Graph(GraphView):
             shared_metadata (PropInput, optional): A dictionary of metadata properties that will be added to every node. Defaults to None.
             schema (list[tuple[str, DataType | PropType | str]] | dict[str, DataType | PropType | str], optional): A list of (column_name, column_type) tuples or dict of {"column_name": column_type} to cast columns to. Defaults to None.
             csv_options (dict[str, str | bool], optional): A dictionary of CSV reading options such as delimiter, comment, escape, quote, and terminator characters, as well as allow_truncated_rows and has_header flags. Defaults to None.
+            event_id (str, optional): The column name for the secondary index. Defaults to None.
+            layer (str, optional): A value to use as the layer for all nodes. Cannot be used in combination with layer_col. Defaults to None.
+            layer_col (str, optional): The node layer column name in a dataframe. Cannot be used in combination with layer. Defaults to None.
 
         Returns:
             None: This function does not return a value if the operation is successful.
@@ -1360,7 +1300,7 @@ class Graph(GraphView):
 
     def save_to_file(self, path: str) -> None:
         """
-         Saves the Graph to the given path.
+         Saves the Graph to the given path in parquet format.
 
         Arguments:
             path (str): The path to the file.
@@ -1389,7 +1329,7 @@ class Graph(GraphView):
 
     def to_parquet(self, graph_dir: str | PathLike) -> None:
         """
-        Persist graph to parquet files.
+        Persist graph to parquet files
 
         Arguments:
             graph_dir (str | PathLike): the folder where the graph will be persisted as parquet
@@ -1412,18 +1352,18 @@ class Graph(GraphView):
             GraphError: If the operation fails.
         """
 
-    def write_updates(self) -> None:
-        """
-        Persist the new updates by appending them to the cache file.
-
-        Returns:
-            None:
-        """
-
 class PersistentGraph(GraphView):
-    """A temporal graph that allows edges and nodes to be deleted."""
+    """
+    A temporal graph that allows edges and nodes to be deleted.
+
+    Arguments:
+        path (str | PathLike, optional): The path for persisting the graph (only works with disk storage enabled). Defaults to None.
+        config (Config, optional): Storage/config overrides. Defaults to None.
+    """
 
-    def __new__(cls) -> PersistentGraph:
+    def __new__(
+        cls, path: Optional[str | PathLike] = None, config: Optional[Config] = None
+    ) -> PersistentGraph:
         """Create and return a new object.  See help(type) for accurate signature."""
 
     def __reduce__(self): ...
@@ -1475,6 +1415,7 @@ class PersistentGraph(GraphView):
         properties: Optional[PropInput] = None,
         node_type: Optional[str] = None,
         event_id: Optional[int] = None,
+        layer: Any = None,
     ) -> None:
         """
         Adds a new node with the given id and properties to the graph.
@@ -1483,8 +1424,9 @@ class PersistentGraph(GraphView):
            timestamp (TimeInput): The timestamp of the node.
            id (str | int): The id of the node.
            properties (PropInput, optional): The properties of the node.
-           node_type (str, optional) : The optional string which will be used as a node type.
+           node_type (str, optional): The optional string which will be used as a node type.
            event_id (int, optional): The optional integer which will be used as an event id.
+           layer: (str, optional): The optional string which will be used as a layer.
 
         Returns:
             None: This function does not return a value, if the operation is successful.
@@ -1511,66 +1453,6 @@ class PersistentGraph(GraphView):
             GraphError: If the operation fails.
         """
 
-    def cache(self, path: str) -> None:
-        """
-         Write PersistentGraph to cache file and initialise the cache.
-
-        Future updates are tracked. Use `write_updates` to persist them to the
-        cache file. If the file already exists its contents are overwritten.
-
-        Arguments:
-            path (str): The path to the cache file
-
-        Returns:
-            None:
-        """
-
-    def create_index(self) -> None:
-        """
-        Create graph index
-
-        Returns:
-            None:
-        """
-
-    def create_index_in_ram(self) -> None:
-        """
-        Creates a graph index in memory (RAM).
-
-        This is primarily intended for use in tests and should not be used in production environments,
-        as the index will not be persisted to disk.
-
-        Returns:
-            None:
-        """
-
-    def create_index_in_ram_with_spec(self, py_spec: IndexSpec) -> None:
-        """
-        Creates a graph index in memory (RAM) with the provided index spec.
-
-        This is primarily intended for use in tests and should not be used in production environments,
-        as the index will not be persisted to disk.
-
-        Arguments:
-            py_spec: The specification for the in-memory index to be created.
-
-         Arguments:
-            py_spec (IndexSpec): The specification for the in-memory index to be created.
-
-        Returns:
-            None:
-        """
-
-    def create_index_with_spec(self, py_spec: Any) -> None:
-        """
-        Create graph index with the provided index spec.
-        Arguments:
-            py_spec: - The specification for the in-memory index to be created.
-
-        Returns:
-            None:
-        """
-
     def create_node(
         self,
         timestamp: TimeInput,
@@ -1578,6 +1460,7 @@ class PersistentGraph(GraphView):
         properties: Optional[PropInput] = None,
         node_type: Optional[str] = None,
         event_id: Optional[int] = None,
+        layer: Optional[str] = None,
     ) -> MutableNode:
         """
         Creates a new node with the given id and properties to the graph. It fails if the node already exists.
@@ -1586,8 +1469,9 @@ class PersistentGraph(GraphView):
            timestamp (TimeInput): The timestamp of the node.
            id (str | int): The id of the node.
            properties (PropInput, optional): The properties of the node.
-           node_type (str, optional) : The optional string which will be used as a node type.
+           node_type (str, optional): The optional string which will be used as a node type.
            event_id (int, optional): The optional integer which will be used as an event id.
+           layer (str, optional): The optional string which will be used as a layer.
 
         Returns:
           MutableNode: the newly created node.
@@ -1653,6 +1537,14 @@ class PersistentGraph(GraphView):
             Graph: the graph with event semantics applied
         """
 
+    def flush(self) -> None:
+        """
+        Trigger a flush of the underlying storage if disk storage is enabled
+
+        Returns:
+            None: This function does not return a value, if the operation is successful.
+        """
+
     def get_all_node_types(self) -> list[str]:
         """
         Returns all the node types in the graph.
@@ -1816,18 +1708,17 @@ class PersistentGraph(GraphView):
         """
 
     @staticmethod
-    def load_cached(path: str) -> PersistentGraph:
+    def load(path: str | PathLike, config: Optional[Config]) -> PersistentGraph:
         """
-         Load PersistentGraph from a file and initialise it as a cache file.
-
-        Future updates are tracked. Use `write_updates` to persist them to the
-        cache file.
+        Load a disk graph from path
 
         Arguments:
-          path (str): The path to the cache file
+            path (str | PathLike): the path of the graph folder
+            config (Config, optional): specify a new config to override the values saved for the graph
+                                       (note that the page sizes cannot be overridden and are ignored)
 
         Returns:
-           PersistentGraph: the loaded graph with initialised cache
+            PersistentGraph: the graph
         """
 
     def load_edge_deletions(
@@ -1843,6 +1734,7 @@ class PersistentGraph(GraphView):
             | dict[str, DataType | PropType | str]
         ] = None,
         csv_options: Optional[dict[str, str | bool]] = None,
+        event_id: Optional[str] = None,
     ) -> None:
         """
         Load edge deletions into the graph from any data source that supports the ArrowStreamExportable protocol (by providing an __arrow_c_stream__() method),
@@ -1859,6 +1751,7 @@ class PersistentGraph(GraphView):
             layer_col (str, optional): The edge layer col name in the data source. Cannot be used in combination with layer. Defaults to None.
             schema (list[tuple[str, DataType | PropType | str]] | dict[str, DataType | PropType | str], optional): A list of (column_name, column_type) tuples or dict of {"column_name": column_type} to cast columns to. Defaults to None.
             csv_options (dict[str, str | bool], optional): A dictionary of CSV reading options such as delimiter, comment, escape, quote, and terminator characters, as well as allow_truncated_rows and has_header flags. Defaults to None.
+            event_id (str, optional): The column name for the secondary index.
 
         Returns:
             None: This function does not return a value, if the operation is successful.
@@ -1922,6 +1815,7 @@ class PersistentGraph(GraphView):
             | dict[str, DataType | PropType | str]
         ] = None,
         csv_options: Optional[dict[str, str | bool]] = None,
+        event_id: Optional[str] = None,
     ) -> None:
         """
         Load edges into the graph from any data source that supports the ArrowStreamExportable protocol (by providing an __arrow_c_stream__() method),
@@ -1941,6 +1835,7 @@ class PersistentGraph(GraphView):
             layer_col (str, optional): The edge layer column name in a dataframe. Cannot be used in combination with layer. Defaults to None.
             schema (list[tuple[str, DataType | PropType | str]] | dict[str, DataType | PropType | str], optional): A list of (column_name, column_type) tuples or dict of {"column_name": column_type} to cast columns to. Defaults to None.
             csv_options (dict[str, str | bool], optional): A dictionary of CSV reading options such as delimiter, comment, escape, quote, and terminator characters, as well as allow_truncated_rows and has_header flags. Defaults to None.
+            event_id (str, optional): The column name for the secondary index.
 
         Returns:
             None: This function does not return a value if the operation is successful.
@@ -1952,7 +1847,7 @@ class PersistentGraph(GraphView):
     @staticmethod
     def load_from_file(path: str) -> PersistentGraph:
         """
-         Load PersistentGraph from a file.
+         Load PersistentGraph from a parquet file.
 
         Arguments:
           path (str): The path to the file.
@@ -1961,6 +1856,39 @@ class PersistentGraph(GraphView):
            PersistentGraph:
         """
 
+    def load_graph_properties(
+        self,
+        data: Any,
+        time: str,
+        properties: Optional[List[str]] = None,
+        metadata: Optional[List[str]] = None,
+        schema: Optional[
+            list[tuple[str, DataType | PropType | str]]
+            | dict[str, DataType | PropType | str]
+        ] = None,
+        event_id: Optional[str] = None,
+    ) -> None:
+        """
+        Load graph properties from any data source that supports the ArrowStreamExportable protocol (by providing an __arrow_c_stream__() method),
+        or a path to a Parquet file, or a directory containing multiple Parquet files.
+        The following are known to support the ArrowStreamExportable protocol: Pandas dataframes, FireDucks(.pandas) dataframes,
+        Polars dataframes, Arrow tables, DuckDB (e.g. DuckDBPyRelation obtained from running an SQL query).
+
+        Arguments:
+            data (Any): The data source containing graph properties.
+            time (str): The column name for the update timestamps.
+            properties (List[str], optional): List of temporal property column names. Defaults to None.
+            metadata (List[str], optional): List of constant property column names. Defaults to None.
+            schema (list[tuple[str, DataType | PropType | str]] | dict[str, DataType | PropType | str], optional): A list of (column_name, column_type) tuples or dict of {"column_name": column_type} to cast columns to. Defaults to None.
+            event_id (str, optional): The column name for the secondary index.
+
+        Returns:
+            None: This function does not return a value if the operation is successful.
+
+        Raises:
+            GraphError: If the operation fails.
+        """
+
     def load_node_metadata(
         self,
         data: Any,
@@ -2013,6 +1941,9 @@ class PersistentGraph(GraphView):
             | dict[str, DataType | PropType | str]
         ] = None,
         csv_options: Optional[dict[str, str | bool]] = None,
+        event_id: Optional[str] = None,
+        layer: Optional[str] = None,
+        layer_col: Optional[str] = None,
     ) -> None:
         """
         Load nodes into the graph from any data source that supports the ArrowStreamExportable protocol (by providing an __arrow_c_stream__() method),
@@ -2031,6 +1962,9 @@ class PersistentGraph(GraphView):
             shared_metadata (PropInput, optional): A dictionary of metadata properties that will be added to every node. Defaults to None.
             schema (list[tuple[str, DataType | PropType | str]] | dict[str, DataType | PropType | str], optional): A list of (column_name, column_type) tuples or dict of {"column_name": column_type} to cast columns to. Defaults to None.
             csv_options (dict[str, str | bool], optional): A dictionary of CSV reading options such as delimiter, comment, escape, quote, and terminator characters, as well as allow_truncated_rows and has_header flags. Defaults to None.
+            event_id (str, optional): The column name for the secondary index.
+            layer (str, optional): A value to use as the layer for all nodes. Cannot be used in combination with layer_col. Defaults to None.
+            layer_col (str, optional): The node layer column name in a dataframe. Cannot be used in combination with layer. Defaults to None.
 
         Returns:
             None: This function does not return a value if the operation is successful.
@@ -2060,7 +1994,7 @@ class PersistentGraph(GraphView):
 
     def save_to_file(self, path: str) -> None:
         """
-         Saves the PersistentGraph to the given path.
+         Saves the PersistentGraph to the given path in parquet format.
 
         Arguments:
             path (str): The path to the file.
@@ -2087,6 +2021,17 @@ class PersistentGraph(GraphView):
           bytes:
         """
 
+    def to_parquet(self, graph_dir: str | PathLike) -> None:
+        """
+        Persist graph to parquet files
+
+        Arguments:
+            graph_dir (str | PathLike): the folder where the graph will be persisted as parquet
+
+        Returns:
+            None:
+        """
+
     def update_metadata(self, metadata: dict) -> None:
         """
         Updates metadata of the graph.
@@ -2101,14 +2046,6 @@ class PersistentGraph(GraphView):
             GraphError: If the operation fails.
         """
 
-    def write_updates(self) -> None:
-        """
-        Persist the new updates by appending them to the cache file.
-
-        Returns:
-            None:
-        """
-
 class Node(object):
     """A node (or node) in the graph."""
 
@@ -3209,7 +3146,7 @@ class PathFromNode(object):
         """
 
     @property
-    def earliest_time(self):
+    def earliest_time(self) -> OptionEventTimeIterable:
         """
         The earliest time of each node.
 
@@ -3331,7 +3268,7 @@ class PathFromNode(object):
         """
 
     @property
-    def id(self):
+    def id(self) -> GIDIterable:
         """
         The node IDs.
 
@@ -3374,7 +3311,7 @@ class PathFromNode(object):
         """
 
     @property
-    def latest_time(self):
+    def latest_time(self) -> OptionEventTimeIterable:
         """
         The latest time of each node.
 
@@ -3416,7 +3353,7 @@ class PathFromNode(object):
         """
 
     @property
-    def name(self):
+    def name(self) -> StringIterable:
         """
         The node names.
 
@@ -3434,7 +3371,7 @@ class PathFromNode(object):
         """
 
     @property
-    def node_type(self):
+    def node_type(self) -> OptionArcStringIterable:
         """
         The node types.
 
@@ -3687,7 +3624,7 @@ class PathFromGraph(object):
              PathFromGraph: The layered view
         """
 
-    def degree(self):
+    def degree(self) -> NestedUsizeIterable:
         """
         Returns the node degrees.
 
@@ -3696,7 +3633,7 @@ class PathFromGraph(object):
         """
 
     @property
-    def earliest_time(self):
+    def earliest_time(self) -> NestedOptionEventTimeIterable:
         """
         The node earliest times.
 
@@ -3704,7 +3641,7 @@ class PathFromGraph(object):
             NestedOptionEventTimeIterable:
         """
 
-    def edge_history_count(self):
+    def edge_history_count(self) -> NestedUsizeIterable:
         """
         Returns the number of edge updates for each node.
 
@@ -3818,7 +3755,7 @@ class PathFromGraph(object):
         """
 
     @property
-    def history(self):
+    def history(self) -> NestedHistoryIterable:
         """
         Returns a history object for each node with time entries for when a node is added or change to a node is made.
 
@@ -3827,7 +3764,7 @@ class PathFromGraph(object):
         """
 
     @property
-    def id(self):
+    def id(self) -> NestedGIDIterable:
         """
         The node ids
 
@@ -3835,7 +3772,7 @@ class PathFromGraph(object):
             NestedGIDIterable:
         """
 
-    def in_degree(self):
+    def in_degree(self) -> NestedUsizeIterable:
         """
         Returns the node in-degrees.
 
@@ -3870,7 +3807,7 @@ class PathFromGraph(object):
         """
 
     @property
-    def latest_time(self):
+    def latest_time(self) -> NestedOptionEventTimeIterable:
         """
         The node latest times.
 
@@ -3903,7 +3840,7 @@ class PathFromGraph(object):
         """
 
     @property
-    def metadata(self):
+    def metadata(self) -> MetadataListList:
         """
         Returns the node metadata.
 
@@ -3912,7 +3849,7 @@ class PathFromGraph(object):
         """
 
     @property
-    def name(self):
+    def name(self) -> NestedStringIterable:
         """
         The node names.
 
@@ -3930,7 +3867,7 @@ class PathFromGraph(object):
         """
 
     @property
-    def node_type(self):
+    def node_type(self) -> NestedOptionArcStringIterable:
         """
         The node types.
 
@@ -3938,7 +3875,7 @@ class PathFromGraph(object):
             NestedOptionArcStringIterable:
         """
 
-    def out_degree(self):
+    def out_degree(self) -> NestedUsizeIterable:
         """
         Returns the node out-degrees.
 
@@ -3965,7 +3902,7 @@ class PathFromGraph(object):
         """
 
     @property
-    def properties(self):
+    def properties(self) -> PyNestedPropsIterable:
         """
         Returns the node properties.
 
@@ -4133,6 +4070,7 @@ class MutableNode(Node):
         t: TimeInput,
         properties: Optional[PropInput] = None,
         event_id: Optional[int] = None,
+        layer: Optional[str] = None,
     ) -> None:
         """
         Add updates to a node in the graph at a specified time.
@@ -4145,6 +4083,7 @@ class MutableNode(Node):
                                              is of type Prop representing the property value.
                                              If None, no properties are updated.
            event_id (int, optional): The optional integer which will be used as an event id.
+           layer (str, optional): The layer this update is recorded under. Defaults to None.
 
         Returns:
             None: This function does not return a value, if the operation is successful.
@@ -4731,7 +4670,7 @@ class Edges(object):
         """
 
     @property
-    def deletions(self):
+    def deletions(self) -> HistoryIterable:
         """
         Returns a history object for each edge containing their deletion times.
 
@@ -4749,7 +4688,7 @@ class Edges(object):
         """
 
     @property
-    def earliest_time(self):
+    def earliest_time(self) -> OptionEventTimeIterable:
         """
         Returns the earliest time of the edges.
 
@@ -4859,7 +4798,7 @@ class Edges(object):
         """
 
     @property
-    def history(self):
+    def history(self) -> HistoryIterable:
         """
         Returns a history object for each edge containing time entries for when the edge is added or change to the edge is made.
 
@@ -4868,7 +4807,7 @@ class Edges(object):
         """
 
     @property
-    def id(self):
+    def id(self) -> GIDGIDIterable:
         """
         Returns all ids of the edges.
 
@@ -4876,7 +4815,7 @@ class Edges(object):
             GIDGIDIterable:
         """
 
-    def is_active(self):
+    def is_active(self) -> BoolIterable:
         """
         Check if the edges are active (there is at least one update during this time).
 
@@ -4884,7 +4823,7 @@ class Edges(object):
             BoolIterable:
         """
 
-    def is_deleted(self):
+    def is_deleted(self) -> BoolIterable:
         """
         Check if the edges are deleted.
 
@@ -4892,7 +4831,7 @@ class Edges(object):
             BoolIterable:
         """
 
-    def is_self_loop(self):
+    def is_self_loop(self) -> BoolIterable:
         """
         Check if the edges are on the same node.
 
@@ -4900,7 +4839,7 @@ class Edges(object):
             BoolIterable:
         """
 
-    def is_valid(self):
+    def is_valid(self) -> BoolIterable:
         """
         Check if the edges are valid (i.e. not deleted).
 
@@ -4917,7 +4856,7 @@ class Edges(object):
         """
 
     @property
-    def latest_time(self):
+    def latest_time(self) -> OptionEventTimeIterable:
         """
         Returns the latest times of the edges.
 
@@ -4938,7 +4877,7 @@ class Edges(object):
         """
 
     @property
-    def layer_name(self):
+    def layer_name(self) -> ArcStringIterable:
         """
         Get the layer name that all edges belong to - assuming they only belong to one layer
 
@@ -4947,7 +4886,7 @@ class Edges(object):
         """
 
     @property
-    def layer_names(self):
+    def layer_names(self) -> ArcStringVecIterable:
         """
         Get the layer names that all edges belong to - assuming they only belong to one layer.
 
@@ -5098,7 +5037,7 @@ class Edges(object):
         """
 
     @property
-    def time(self):
+    def time(self) -> EventTimeIterable:
         """
         Returns the times of exploded edges
 
@@ -5229,7 +5168,7 @@ class NestedEdges(object):
         """
 
     @property
-    def deletions(self):
+    def deletions(self) -> NestedHistoryIterable:
         """
         Returns a history object for each edge containing their deletion times.
 
@@ -5247,7 +5186,7 @@ class NestedEdges(object):
         """
 
     @property
-    def earliest_time(self):
+    def earliest_time(self) -> NestedOptionEventTimeIterable:
         """
         Returns the earliest time of the edges.
 
@@ -5357,7 +5296,7 @@ class NestedEdges(object):
         """
 
     @property
-    def history(self):
+    def history(self) -> NestedHistoryIterable:
         """
         Returns a history object for each edge containing time entries for when the edge is added or change to the edge is made.
 
@@ -5366,7 +5305,7 @@ class NestedEdges(object):
         """
 
     @property
-    def id(self):
+    def id(self) -> NestedGIDGIDIterable:
         """
         Returns all ids of the edges.
 
@@ -5374,7 +5313,7 @@ class NestedEdges(object):
             NestedGIDGIDIterable:
         """
 
-    def is_active(self):
+    def is_active(self) -> NestedBoolIterable:
         """
         Check if the edges are active (there is at least one update during this time).
 
@@ -5382,7 +5321,7 @@ class NestedEdges(object):
             NestedBoolIterable:
         """
 
-    def is_deleted(self):
+    def is_deleted(self) -> NestedBoolIterable:
         """
         Check if edges are deleted.
 
@@ -5390,7 +5329,7 @@ class NestedEdges(object):
             NestedBoolIterable:
         """
 
-    def is_self_loop(self):
+    def is_self_loop(self) -> NestedBoolIterable:
         """
         Check if the edges are on the same node.
 
@@ -5398,7 +5337,7 @@ class NestedEdges(object):
             NestedBoolIterable:
         """
 
-    def is_valid(self):
+    def is_valid(self) -> NestedBoolIterable:
         """
         Check if edges are valid (i.e., not deleted).
 
@@ -5415,7 +5354,7 @@ class NestedEdges(object):
         """
 
     @property
-    def latest_time(self):
+    def latest_time(self) -> NestedOptionEventTimeIterable:
         """
         Returns the latest time of the edges.
 
@@ -5436,7 +5375,7 @@ class NestedEdges(object):
         """
 
     @property
-    def layer_name(self):
+    def layer_name(self) -> NestedArcStringIterable:
         """
         Returns the name of the layer the edges belong to - assuming they only belong to one layer.
 
@@ -5445,7 +5384,7 @@ class NestedEdges(object):
         """
 
     @property
-    def layer_names(self):
+    def layer_names(self) -> NestedArcStringVecIterable:
         """
         Returns the names of the layers the edges belong to.
 
@@ -5466,7 +5405,7 @@ class NestedEdges(object):
         """
 
     @property
-    def metadata(self):
+    def metadata(self) -> MetadataListList:
         """
         Get a view of the metadata only.
 
@@ -5484,7 +5423,7 @@ class NestedEdges(object):
         """
 
     @property
-    def properties(self):
+    def properties(self) -> PyNestedPropsIterable:
         """
         Returns all properties of the edges
 
@@ -5596,7 +5535,7 @@ class NestedEdges(object):
         """
 
     @property
-    def time(self):
+    def time(self) -> NestedEventTimeIterable:
         """
         Returns the times of exploded edges.
 
@@ -5852,8 +5791,22 @@ class PyPropValueList(object):
             PropValue: The average of each property values, or None if count is zero.
         """
 
-    def collect(self): ...
-    def count(self): ...
+    def collect(self) -> list:
+        """
+        Materialise the iterable as a Python list.
+
+        Returns:
+            list:
+        """
+
+    def count(self) -> int:
+        """
+        Number of properties (or rows of properties).
+
+        Returns:
+            int:
+        """
+
     def drop_none(self) -> list[PropValue]:
         """
         Drop none.
@@ -5935,35 +5888,149 @@ class PropType(object):
         """Return str(self)."""
 
     @staticmethod
-    def array(p): ...
+    def bool() -> PropType:
+        """
+        Boolean type.
+
+        Returns:
+            PropType:
+        """
+
     @staticmethod
-    def bool(): ...
+    def datetime() -> PropType:
+        """
+        Datetime type (timezone-aware).
+
+        Returns:
+            PropType:
+        """
+
     @staticmethod
-    def datetime(): ...
+    def decimal(scale: int) -> PropType:
+        """
+        Arbitrary-precision decimal type with a fixed scale (number of digits
+        after the decimal point).
+
+        Arguments:
+            scale (int): the number of digits after the decimal point.
+
+        Returns:
+            PropType:
+        """
+
     @staticmethod
-    def f32(): ...
+    def f32() -> PropType:
+        """
+        32-bit float type.
+
+        Returns:
+            PropType:
+        """
+
     @staticmethod
-    def f64(): ...
+    def f64() -> PropType:
+        """
+        64-bit float type.
+
+        Returns:
+            PropType:
+        """
+
     @staticmethod
-    def i32(): ...
+    def i32() -> PropType:
+        """
+        Signed 32-bit integer type.
+
+        Returns:
+            PropType:
+        """
+
     @staticmethod
-    def i64(): ...
+    def i64() -> PropType:
+        """
+        Signed 64-bit integer type.
+
+        Returns:
+            PropType:
+        """
+
     @staticmethod
-    def list(p): ...
+    def list(p: PropType) -> PropType:
+        """
+        List type with a single element type.
+
+        Arguments:
+            p (PropType): element type.
+
+        Returns:
+            PropType:
+        """
+
     @staticmethod
-    def map(hash_map): ...
+    def map(hash_map: dict[str, PropType]) -> PropType:
+        """
+        Map type with string keys and typed values.
+
+        Arguments:
+            hash_map (dict[str, PropType]): mapping from key name to value type.
+
+        Returns:
+            PropType:
+        """
+
     @staticmethod
-    def naive_datetime(): ...
+    def naive_datetime() -> PropType:
+        """
+        Naive datetime type (timezone-unaware).
+
+        Returns:
+            PropType:
+        """
+
     @staticmethod
-    def str(): ...
+    def str() -> PropType:
+        """
+        String type.
+
+        Returns:
+            PropType:
+        """
+
     @staticmethod
-    def u16(): ...
+    def u16() -> PropType:
+        """
+        Unsigned 16-bit integer type.
+
+        Returns:
+            PropType:
+        """
+
     @staticmethod
-    def u32(): ...
+    def u32() -> PropType:
+        """
+        Unsigned 32-bit integer type.
+
+        Returns:
+            PropType:
+        """
+
     @staticmethod
-    def u64(): ...
+    def u64() -> PropType:
+        """
+        Unsigned 64-bit integer type.
+
+        Returns:
+            PropType:
+        """
+
     @staticmethod
-    def u8(): ...
+    def u8() -> PropType:
+        """
+        Unsigned 8-bit integer type.
+
+        Returns:
+            PropType:
+        """
 
 class Metadata(object):
     """A view of metadata of an entity"""
@@ -6074,11 +6141,49 @@ class MetadataView(object):
     def __ne__(self, value):
         """Return self!=value."""
 
-    def as_dict(self): ...
-    def get(self, key): ...
-    def items(self): ...
-    def keys(self): ...
-    def values(self): ...
+    def as_dict(self) -> dict[str, list]:
+        """
+        Materialise the metadata as a plain dict mapping each key to the
+        list of values seen across the underlying entities.
+
+        Returns:
+            dict[str, list]:
+        """
+
+    def get(self, key: str) -> Optional[PyPropValueList]:
+        """
+        Look up a metadata value by key.
+
+        Arguments:
+            key (str): metadata key.
+
+        Returns:
+            Optional[PyPropValueList]:
+        """
+
+    def items(self) -> list[tuple[str, PyPropValueList]]:
+        """
+        Pairs of `(key, value list)` for every metadata key.
+
+        Returns:
+            list[tuple[str, PyPropValueList]]:
+        """
+
+    def keys(self) -> list[str]:
+        """
+        Metadata keys present across the underlying entities.
+
+        Returns:
+            list[str]:
+        """
+
+    def values(self) -> list[PyPropValueList]:
+        """
+        Metadata values aligned with `keys()`.
+
+        Returns:
+            list[PyPropValueList]:
+        """
 
 class TemporalProperties(object):
     """A view of the temporal properties of an entity"""
@@ -6234,12 +6339,12 @@ class PropertiesView(object):
         """
 
     @property
-    def temporal(self):
+    def temporal(self) -> list[TemporalProperty]:
         """
         Get a view of the temporal properties only.
 
         Returns:
-            List[TemporalProp]:
+            list[TemporalProperty]:
         """
 
     def values(self) -> list[list[PropValue]]:
@@ -6388,18 +6493,18 @@ class TemporalProperty(object):
             Optional[PropValue]:
         """
 
-    def values(self):
+    def values(self) -> NDArray:
         """
         Get the property values for each update.
 
         Returns:
-            NumpyArray:
+            NDArray: a numpy array of values, one per update.
         """
 
 class EventTime(object):
     """
-    Raphtory’s EventTime.
-    Represents a unique timepoint in the graph’s history as (timestamp, event_id).
+    Raphtory's EventTime.
+    Represents a unique timepoint in the graph's history as (timestamp, event_id).
 
     - timestamp: Number of milliseconds since the Unix epoch.
     - event_id: ID used for ordering between equal timestamps.
@@ -6409,6 +6514,10 @@ class EventTime(object):
     EventTime can be converted into a timestamp or a Python datetime, and compared
     either by timestamp (against ints/floats/datetimes/strings), by tuple of (timestamp, event_id),
     or against another EventTime.
+
+    Arguments:
+        timestamp (int | float | datetime | str): A time input convertible to an EventTime.
+        event_id (int | float | datetime | str | None): Optionally, specify the event id. Defaults to None.
     """
 
     def __eq__(self, value):
@@ -6435,7 +6544,11 @@ class EventTime(object):
     def __ne__(self, value):
         """Return self!=value."""
 
-    def __new__(cls, timestamp, event_id=None) -> EventTime:
+    def __new__(
+        cls,
+        timestamp: int | float | datetime | str,
+        event_id: int | float | datetime | str | None = None,
+    ) -> EventTime:
         """Create and return a new object.  See help(type) for accurate signature."""
 
     def __repr__(self):
@@ -6512,41 +6625,41 @@ class OptionalEventTime(object):
         """Return self!=value."""
 
     @property
-    def as_tuple(self):
+    def as_tuple(self) -> Optional[tuple[int, int]]:
         """
         Return this entry as a tuple of (timestamp, event_id), where the timestamp is in milliseconds if an EventTime is contained, or else None.
 
         Returns:
-            tuple[int,int] | None: (timestamp, event_id).
+            Optional[tuple[int, int]]: (timestamp, event_id).
         """
 
     @property
-    def dt(self):
+    def dt(self) -> Optional[datetime]:
         """
         Returns the UTC datetime representation of this EventTime's timestamp if an EventTime is contained, or else None.
 
         Returns:
-            datetime | None: The UTC datetime.
+            Optional[datetime]: The UTC datetime.
 
         Raises:
             TimeError: Returns TimeError on timestamp conversion errors (e.g. out-of-range timestamp).
         """
 
     @property
-    def event_id(self):
+    def event_id(self) -> Optional[int]:
         """
         Returns the event id used to order events within the same timestamp if an EventTime is contained, or else None.
 
         Returns:
-            int | None: The event id.
+            Optional[int]: The event id.
         """
 
-    def get_event_time(self):
+    def get_event_time(self) -> Optional[EventTime]:
         """
         Returns the contained EventTime if it exists, or else None.
 
         Returns:
-            EventTime | None:
+            Optional[EventTime]:
         """
 
     def is_none(self) -> bool:
@@ -6566,12 +6679,12 @@ class OptionalEventTime(object):
         """
 
     @property
-    def t(self):
+    def t(self) -> Optional[int]:
         """
         Returns the timestamp in milliseconds since the Unix epoch if an EventTime is contained, or else None.
 
         Returns:
-            int | None: Milliseconds since the Unix epoch.
+            Optional[int]: Milliseconds since the Unix epoch.
         """
 
 class History(object):
@@ -7060,179 +7173,222 @@ class WindowSet(object):
             Iterable: The time index.
         """
 
-class IndexSpecBuilder(object):
-    def __new__(cls, graph) -> IndexSpecBuilder:
-        """Create and return a new object.  See help(type) for accurate signature."""
+class Prop(object):
+    def __eq__(self, value):
+        """Return self==value."""
+
+    def __ge__(self, value):
+        """Return self>=value."""
+
+    def __gt__(self, value):
+        """Return self>value."""
+
+    def __hash__(self):
+        """Return hash(self)."""
+
+    def __le__(self, value):
+        """Return self<=value."""
+
+    def __lt__(self, value):
+        """Return self<value."""
+
+    def __ne__(self, value):
+        """Return self!=value."""
 
-    def build(self) -> IndexSpec:
+    def __repr__(self):
+        """Return repr(self)."""
+
+    @staticmethod
+    def aware_datetime(value: datetime) -> Prop:
         """
-        Return a spec
+        Construct a `Prop` holding a timezone-aware datetime (stored as UTC).
+        Naive datetimes are accepted and interpreted as UTC, matching the
+        convention used elsewhere in Raphtory's time inputs.
+
+        Arguments:
+            value (datetime): a datetime. Naive datetimes are treated as UTC.
 
         Returns:
-            IndexSpec:
+            Prop:
         """
 
-    def with_all_edge_metadata(self) -> dict[str, Any]:
+    @staticmethod
+    def bool(value: bool) -> Prop:
         """
-        Adds all edge metadata to the spec.
+        Construct a `Prop` holding a boolean.
+
+        Arguments:
+            value (bool): the value to wrap.
 
         Returns:
-            dict[str, Any]:
+            Prop:
         """
 
-    def with_all_edge_properties(self) -> dict[str, Any]:
+    @staticmethod
+    def decimal(value: Decimal | str | int | float) -> Prop:
         """
-        Adds all edge properties to the spec.
+        Construct a `Prop` holding an arbitrary-precision decimal.
+
+        Arguments:
+            value (Decimal | str | int | float): the value to wrap. Strings must
+                parse as a decimal. Note that floats only have ~15-17 digits of
+                precision — pass a string or `decimal.Decimal` for higher precision.
 
         Returns:
-            dict[str, Any]:
+            Prop:
         """
 
-    def with_all_edge_properties_and_metadata(self) -> dict[str, Any]:
+    def dtype(self) -> PropType:
         """
-        Adds all edge properties and metadata to the spec.
+        Returns the `PropType` of the wrapped value.
 
         Returns:
-            dict[str, Any]:
+            PropType:
         """
 
-    def with_all_node_metadata(self) -> dict[str, Any]:
+    @staticmethod
+    def f32(value: float) -> Prop:
         """
-        Adds all node metadata to the spec.
+        Construct a `Prop` holding a 32-bit float.
+
+        Arguments:
+            value (float): the value to wrap.
 
         Returns:
-            dict[str, Any]:
+            Prop:
         """
 
-    def with_all_node_properties(self) -> dict[str, Any]:
+    @staticmethod
+    def f64(value: float) -> Prop:
         """
-        Adds all node properties to the spec.
+        Construct a `Prop` holding a 64-bit float.
+
+        Arguments:
+            value (float): the value to wrap.
 
         Returns:
-            dict[str, Any]:
+            Prop:
         """
 
-    def with_all_node_properties_and_metadata(self) -> dict[str, Any]:
+    @staticmethod
+    def i32(value: int) -> Prop:
         """
-        Adds all node properties and metadata to the spec.
+        Construct a `Prop` holding a signed 32-bit integer.
+
+        Arguments:
+            value (int): the value to wrap.
 
         Returns:
-            dict[str, Any]:
+            Prop:
         """
 
-    def with_edge_metadata(self, props: Any) -> dict[str, Any]:
+    @staticmethod
+    def i64(value: int) -> Prop:
         """
-        Adds specified edge metadata to the spec.
+        Construct a `Prop` holding a signed 64-bit integer.
 
         Arguments:
-            props: List of metadata.
+            value (int): the value to wrap.
 
         Returns:
-            dict[str, Any]:
+            Prop:
         """
 
-    def with_edge_properties(self, props: Any) -> dict[str, Any]:
+    @staticmethod
+    def list(values: list) -> Prop:
         """
-        Adds specified edge properties to the spec.
+        Construct a `Prop` holding a list of values.
 
         Arguments:
-            props: List of properties.
+            values (list): the values to wrap.
 
         Returns:
-            dict[str, Any]:
+            Prop:
         """
 
-    def with_node_metadata(self, props: Any) -> dict[str, Any]:
+    @staticmethod
+    def map(dict: dict[str, Any]) -> Prop:
         """
-        Adds specified node metadata to the spec.
+        Construct a `Prop` holding a string-keyed map of values.
 
         Arguments:
-            props: list of metadata.
+            dict (dict[str, Any]): the map to wrap.
 
         Returns:
-            dict[str, Any]:
+            Prop:
         """
 
-    def with_node_properties(self, props: Any) -> dict[str, Any]:
+    @staticmethod
+    def naive_datetime(value: datetime) -> Prop:
         """
-        Adds specified node properties to the spec.
+        Construct a `Prop` holding a naive (timezone-unaware) datetime.
 
         Arguments:
-            props: list of properties.
+            value (datetime): the value to wrap (any tz info is dropped).
 
         Returns:
-            dict[str, Any]:
+            Prop:
         """
 
-class IndexSpec(object):
-    def __repr__(self):
-        """Return repr(self)."""
-
-    @property
-    def edge_metadata(self) -> list[str]:
+    @staticmethod
+    def str(value: str) -> Prop:
         """
-        Get edge metadata.
+        Construct a `Prop` holding a string.
+
+        Arguments:
+            value (str): the value to wrap.
 
         Returns:
-            list[str]:
+            Prop:
         """
 
-    @property
-    def edge_properties(self) -> list[str]:
+    @staticmethod
+    def u16(value: int) -> Prop:
         """
-        Get edge properties.
+        Construct a `Prop` holding an unsigned 16-bit integer.
+
+        Arguments:
+            value (int): the value to wrap.
 
         Returns:
-            list[str]:
+            Prop:
         """
 
-    @property
-    def node_metadata(self) -> list[str]:
+    @staticmethod
+    def u32(value: int) -> Prop:
         """
-        Get node metadata.
+        Construct a `Prop` holding an unsigned 32-bit integer.
+
+        Arguments:
+            value (int): the value to wrap.
 
         Returns:
-            list[str]:
+            Prop:
         """
 
-    @property
-    def node_properties(self) -> list[str]:
+    @staticmethod
+    def u64(value: int) -> Prop:
         """
-        Get node properties.
+        Construct a `Prop` holding an unsigned 64-bit integer.
+
+        Arguments:
+            value (int): the value to wrap.
 
         Returns:
-            list[str]:
+            Prop:
         """
 
-class Prop(object):
-    def __repr__(self):
-        """Return repr(self)."""
-
-    @staticmethod
-    def bool(value): ...
-    def dtype(self): ...
-    @staticmethod
-    def f32(value): ...
-    @staticmethod
-    def f64(value): ...
-    @staticmethod
-    def i32(value): ...
-    @staticmethod
-    def i64(value): ...
     @staticmethod
-    def list(values): ...
-    @staticmethod
-    def map(dict): ...
-    @staticmethod
-    def str(value): ...
-    @staticmethod
-    def u16(value): ...
-    @staticmethod
-    def u32(value): ...
-    @staticmethod
-    def u64(value): ...
-    @staticmethod
-    def u8(value): ...
+    def u8(value: int) -> Prop:
+        """
+        Construct a `Prop` holding an unsigned 8-bit integer.
+
+        Arguments:
+            value (int): the value to wrap.
+
+        Returns:
+            Prop:
+        """
 
 def version() -> str:
     """
diff --git a/python/python/raphtory/algorithms/__init__.pyi b/python/python/raphtory/algorithms/__init__.pyi
index c185492cf8..03a058a0cc 100644
--- a/python/python/raphtory/algorithms/__init__.pyi
+++ b/python/python/raphtory/algorithms/__init__.pyi
@@ -19,13 +19,17 @@ import raphtory.filter as filter
 from raphtory.vectors import *
 from raphtory.node_state import *
 from raphtory.graphql import *
+from raphtory.gql import *
 from raphtory.typing import *
 import numpy as np
 from numpy.typing import NDArray
 from datetime import datetime
+import pandas
 from pandas import DataFrame
+import pyarrow  # type: ignore[import-untyped]
 from pyarrow import DataType  # type: ignore[import-untyped]
 from os import PathLike
+from decimal import Decimal
 import networkx as nx  # type: ignore
 import pyvis  # type: ignore
 from raphtory.iterables import *
@@ -204,7 +208,7 @@ def directed_graph_density(graph: GraphView) -> float:
         float: Directed graph density of graph.
     """
 
-def degree_centrality(graph: GraphView):
+def degree_centrality(graph: GraphView) -> OutputNodeState:
     """
     Computes the degree centrality of all nodes in the graph. The values are normalized
     by dividing each result with the maximum possible degree. Graphs with self-loops can have
@@ -214,10 +218,10 @@ def degree_centrality(graph: GraphView):
         graph (GraphView): The graph view on which the operation is to be performed.
 
     Returns:
-        PyOutputNodeState: NodeState mapping nodes to their associated degree centrality.
+        OutputNodeState: NodeState mapping nodes to their associated degree centrality.
     """
 
-def alternating_mask(graph: GraphView):
+def alternating_mask(graph: GraphView) -> OutputNodeState:
     """
     Alternating mask algorithm. It is a mock algorithm suitable only for testing purposes.
 
@@ -225,7 +229,7 @@ def alternating_mask(graph: GraphView):
         graph (GraphView): The graph view on which the operation is to be performed.
 
     Returns:
-        PyOutputNodeState: NodeState mapping nodes to their associated alternating masks.
+        OutputNodeState: NodeState mapping nodes to their associated alternating masks.
     """
 
 def max_degree(graph: GraphView) -> int:
@@ -300,7 +304,7 @@ def pagerank(
     max_diff: Optional[float] = None,
     use_l2_norm: bool = True,
     damping_factor: float = 0.85,
-):
+) -> OutputNodeState:
     """
     Pagerank -- pagerank centrality value of the nodes in a graph
 
@@ -318,7 +322,7 @@ def pagerank(
         damping_factor (float): The damping factor for the PageRank calculation. Defaults to 0.85.
 
     Returns:
-        PyOutputNodeState: NodeState mapping nodes to their pagerank score.
+        OutputNodeState: NodeState mapping nodes to their pagerank score.
     """
 
 def single_source_shortest_path(
@@ -409,7 +413,7 @@ def local_clustering_coefficient(graph: GraphView, v: NodeInput) -> float:
         float: the local clustering coefficient of node v in graph.
     """
 
-def local_clustering_coefficient_batch(graph: Any, v: Any = None):
+def local_clustering_coefficient_batch(graph: Any, v: Any = None) -> OutputNodeState:
     """
     Returns the Local clustering coefficient (batch, intersection) for each specified node in a graph. This measures the degree to which one or multiple nodes in a graph tend to cluster together.
 
@@ -420,7 +424,7 @@ def local_clustering_coefficient_batch(graph: Any, v: Any = None):
         v: vec of node ids, if empty, will return results for every node in the graph
 
     Returns:
-        PyOutputNodeState: Mapping of vertices to lcc score
+        OutputNodeState: Mapping of vertices to lcc score
     """
 
 def weakly_connected_components(graph: GraphView) -> NodeStateUsize:
@@ -437,7 +441,7 @@ def weakly_connected_components(graph: GraphView) -> NodeStateUsize:
         NodeStateUsize: Mapping of nodes to their component ids.
     """
 
-def strongly_connected_components(graph: GraphView):
+def strongly_connected_components(graph: GraphView) -> OutputNodeState:
     """
     Strongly connected components
 
@@ -447,7 +451,7 @@ def strongly_connected_components(graph: GraphView):
         graph (GraphView): Raphtory graph
 
     Returns:
-        PyOutputNodeState: NodeState mapping nodes to their component ids
+        OutputNodeState: NodeState mapping nodes to their component ids
     """
 
 def in_components(
@@ -596,7 +600,7 @@ def global_temporal_three_node_motif_multi(
     """
 
 def local_temporal_three_node_motifs(
-    graph: GraphView, delta: int, threads=None
+    graph: GraphView, delta: int, threads: Optional[int] = None
 ) -> NodeStateMotifs:
     """
     Computes the number of each type of motif that each node participates in. See global_temporal_three_node_motifs for a summary of the motifs involved.
@@ -604,6 +608,7 @@ def local_temporal_three_node_motifs(
     Arguments:
         graph (GraphView): A directed raphtory graph
         delta (int): Maximum time difference between the first and last edge of the motif. NB if time for edges was given as a UNIX epoch, this should be given in seconds, otherwise milliseconds should be used (if edge times were given as string)
+        threads (int, optional): Number of threads to use. Defaults to None.
 
     Returns:
         NodeStateMotifs: A mapping from nodes to lists of motif counts (40 counts in the same order as the global motif counts) with the number of each motif that node participates in.
@@ -656,18 +661,18 @@ def balance(
     """
 
 def label_propagation(
-    graph: GraphView, iter_count: Any = 20, seed: Optional[bytes] = None
-):
+    graph: GraphView, iter_count: int = 20, seed: Optional[bytes] = None
+) -> OutputNodeState:
     """
     Computes components using a label propagation algorithm
 
     Arguments:
         graph (GraphView): A reference to the graph
-        iter_count: Number of iterations
+        iter_count (int): Number of iterations. Defaults to 20.
         seed (bytes, optional): Array of 32 bytes of u8 which is set as the rng seed
 
     Returns:
-        PyOutputNodeState: NodeState mapping nodes to community id
+        OutputNodeState: NodeState mapping nodes to community id
 
     """
 
diff --git a/python/python/raphtory/filter/__init__.pyi b/python/python/raphtory/filter/__init__.pyi
index 9eb7ac3078..05eb32788e 100644
--- a/python/python/raphtory/filter/__init__.pyi
+++ b/python/python/raphtory/filter/__init__.pyi
@@ -15,13 +15,17 @@ from raphtory.algorithms import *
 from raphtory.vectors import *
 from raphtory.node_state import *
 from raphtory.graphql import *
+from raphtory.gql import *
 from raphtory.typing import *
 import numpy as np
 from numpy.typing import NDArray
 from datetime import datetime
+import pandas
 from pandas import DataFrame
+import pyarrow  # type: ignore[import-untyped]
 from pyarrow import DataType  # type: ignore[import-untyped]
 from os import PathLike
+from decimal import Decimal
 import networkx as nx  # type: ignore
 import pyvis  # type: ignore
 from raphtory.iterables import *
@@ -89,14 +93,29 @@ class FilterOps(object):
     def __ne__(self, value):
         """Return self!=value."""
 
-    def all(self):
-        """Requires that **all** elements match when the underlying property is list-like."""
+    def all(self) -> filter.PropertyFilterOps:
+        """
+        Requires that **all** elements match when the underlying property is list-like.
+
+        Returns:
+            filter.PropertyFilterOps:
+        """
 
-    def any(self):
-        """Requires that **any** element matches when the underlying property is list-like."""
+    def any(self) -> filter.PropertyFilterOps:
+        """
+        Requires that **any** element matches when the underlying property is list-like.
 
-    def avg(self):
-        """Averages list elements when the underlying property is numeric and list-like."""
+        Returns:
+            filter.PropertyFilterOps:
+        """
+
+    def avg(self) -> filter.PropertyFilterOps:
+        """
+        Averages list elements when the underlying property is numeric and list-like.
+
+        Returns:
+            filter.PropertyFilterOps:
+        """
 
     def contains(self, value: Prop) -> filter.FilterExpr:
         """
@@ -120,8 +139,13 @@ class FilterOps(object):
             filter.FilterExpr: A filter expression evaluating suffix matching.
         """
 
-    def first(self):
-        """Selects the first element when the underlying property is list-like."""
+    def first(self) -> filter.PropertyFilterOps:
+        """
+        Selects the first element when the underlying property is list-like.
+
+        Returns:
+            filter.PropertyFilterOps:
+        """
 
     def fuzzy_search(
         self, prop_value: str, levenshtein_distance: int, prefix_match: bool
@@ -178,17 +202,37 @@ class FilterOps(object):
             filter.FilterExpr: A filter expression evaluating `value is not None`.
         """
 
-    def last(self):
-        """Selects the last element when the underlying property is list-like."""
+    def last(self) -> filter.PropertyFilterOps:
+        """
+        Selects the last element when the underlying property is list-like.
 
-    def len(self):
-        """Returns the list length when the underlying property is list-like."""
+        Returns:
+            filter.PropertyFilterOps:
+        """
 
-    def max(self):
-        """Returns the maximum list element when the underlying property is list-like."""
+    def len(self) -> filter.PropertyFilterOps:
+        """
+        Returns the list length when the underlying property is list-like.
 
-    def min(self):
-        """Returns the minimum list element when the underlying property is list-like."""
+        Returns:
+            filter.PropertyFilterOps:
+        """
+
+    def max(self) -> filter.PropertyFilterOps:
+        """
+        Returns the maximum list element when the underlying property is list-like.
+
+        Returns:
+            filter.PropertyFilterOps:
+        """
+
+    def min(self) -> filter.PropertyFilterOps:
+        """
+        Returns the minimum list element when the underlying property is list-like.
+
+        Returns:
+            filter.PropertyFilterOps:
+        """
 
     def not_contains(self, value: Prop) -> filter.FilterExpr:
         """
@@ -212,8 +256,13 @@ class FilterOps(object):
             filter.FilterExpr: A filter expression evaluating prefix matching.
         """
 
-    def sum(self):
-        """Sums list elements when the underlying property is numeric and list-like."""
+    def sum(self) -> filter.PropertyFilterOps:
+        """
+        Sums list elements when the underlying property is numeric and list-like.
+
+        Returns:
+            filter.PropertyFilterOps:
+        """
 
 class PropertyFilterOps(FilterOps):
     """
@@ -244,7 +293,7 @@ class Node(object):
     """
 
     @staticmethod
-    def after(time: int):
+    def after(time: int) -> filter.NodeViewPropsFilterBuilder:
         """
         Restricts node evaluation to times strictly after the given time.
 
@@ -252,11 +301,11 @@ class Node(object):
             time (int): Lower time bound.
 
         Returns:
-            filter.NodeViewPropsFilterBuilder
+            filter.NodeViewPropsFilterBuilder:
         """
 
     @staticmethod
-    def at(time: int):
+    def at(time: int) -> filter.NodeViewPropsFilterBuilder:
         """
         Restricts node evaluation to a single point in time.
 
@@ -264,11 +313,11 @@ class Node(object):
             time (int): Event time.
 
         Returns:
-            filter.NodeViewPropsFilterBuilder
+            filter.NodeViewPropsFilterBuilder:
         """
 
     @staticmethod
-    def before(time: int):
+    def before(time: int) -> filter.NodeViewPropsFilterBuilder:
         """
         Restricts node evaluation to times strictly before the given time.
 
@@ -276,40 +325,51 @@ class Node(object):
             time (int): Upper time bound.
 
         Returns:
-            filter.NodeViewPropsFilterBuilder
+            filter.NodeViewPropsFilterBuilder:
         """
 
     @staticmethod
-    def by_state_column(state, col): ...
+    def by_state_column(state: OutputNodeState, col: str) -> filter.FilterExpr:
+        """
+        Build a node filter from a boolean column of an existing node-state result.
+
+        Arguments:
+            state (OutputNodeState): A pre-computed node state (e.g. from an algorithm).
+            col (str): Name of the boolean column on `state` whose values determine inclusion.
+
+        Returns:
+            filter.FilterExpr:
+        """
+
     @staticmethod
-    def id():
+    def id() -> filter.NodeIdFilterBuilder:
         """
         Selects the node ID field for filtering.
 
         Returns:
-            filter.NodeIdFilterBuilder
+            filter.NodeIdFilterBuilder:
         """
 
     @staticmethod
-    def is_active():
+    def is_active() -> filter.FilterExpr:
         """
         Matches nodes that have at least one event in the current view.
 
         Returns:
-            filter.FilterExpr
+            filter.FilterExpr:
         """
 
     @staticmethod
-    def latest():
+    def latest() -> filter.NodeViewPropsFilterBuilder:
         """
         Evaluates filters against the latest available state of each node.
 
         Returns:
-            filter.NodeViewPropsFilterBuilder
+            filter.NodeViewPropsFilterBuilder:
         """
 
     @staticmethod
-    def layer(layer: str):
+    def layer(layer: str) -> filter.NodeViewPropsFilterBuilder:
         """
         Restricts evaluation to nodes belonging to the given layer.
 
@@ -317,11 +377,11 @@ class Node(object):
             layer (str): Layer name.
 
         Returns:
-            filter.NodeViewPropsFilterBuilder
+            filter.NodeViewPropsFilterBuilder:
         """
 
     @staticmethod
-    def layers(layers: list[str]):
+    def layers(layers: list[str]) -> filter.NodeViewPropsFilterBuilder:
         """
         Restricts evaluation to nodes belonging to any of the given layers.
 
@@ -329,11 +389,11 @@ class Node(object):
             layers (list[str]): Layer names.
 
         Returns:
-            filter.NodeViewPropsFilterBuilder
+            filter.NodeViewPropsFilterBuilder:
         """
 
     @staticmethod
-    def metadata(name: str):
+    def metadata(name: str) -> filter.FilterOps:
         """
         Filters a node metadata field by name.
 
@@ -343,29 +403,29 @@ class Node(object):
             name (str): Metadata key.
 
         Returns:
-            filter.FilterOps
+            filter.FilterOps:
         """
 
     @staticmethod
-    def name():
+    def name() -> filter.NodeNameFilterBuilder:
         """
         Selects the node name field for filtering.
 
         Returns:
-            filter.NodeNameFilterBuilder
+            filter.NodeNameFilterBuilder:
         """
 
     @staticmethod
-    def node_type():
+    def node_type() -> filter.NodeTypeFilterBuilder:
         """
         Selects the node type field for filtering.
 
         Returns:
-            filter.NodeTypeFilterBuilder
+            filter.NodeTypeFilterBuilder:
         """
 
     @staticmethod
-    def property(name: str):
+    def property(name: str) -> filter.PropertyFilterOps:
         """
         Filters a node property by name.
 
@@ -375,11 +435,11 @@ class Node(object):
             name (str): Property key.
 
         Returns:
-            filter.PropertyFilterOps
+            filter.PropertyFilterOps:
         """
 
     @staticmethod
-    def snapshot_at(time: int):
+    def snapshot_at(time: int) -> filter.NodeViewPropsFilterBuilder:
         """
         Evaluates filters against a snapshot of the graph at a given time.
 
@@ -387,20 +447,20 @@ class Node(object):
             time (int): Snapshot time.
 
         Returns:
-            filter.NodeViewPropsFilterBuilder
+            filter.NodeViewPropsFilterBuilder:
         """
 
     @staticmethod
-    def snapshot_latest():
+    def snapshot_latest() -> filter.NodeViewPropsFilterBuilder:
         """
         Evaluates filters against the most recent snapshot of the graph.
 
         Returns:
-            filter.NodeViewPropsFilterBuilder
+            filter.NodeViewPropsFilterBuilder:
         """
 
     @staticmethod
-    def window(start: int, end: int):
+    def window(start: int, end: int) -> filter.NodeViewPropsFilterBuilder:
         """
         Restricts node evaluation to the given time window.
 
@@ -411,7 +471,7 @@ class Node(object):
             end (int): End time.
 
         Returns:
-            filter.NodeViewPropsFilterBuilder
+            filter.NodeViewPropsFilterBuilder:
         """
 
 class NodeIdFilterBuilder(object):
@@ -791,7 +851,7 @@ class Edge(object):
     """
 
     @staticmethod
-    def after(time: int):
+    def after(time: int) -> filter.EdgeViewPropsFilterBuilder:
         """
         Restricts edge evaluation to times strictly after the given time.
 
@@ -799,11 +859,11 @@ class Edge(object):
             time (int): Lower time bound.
 
         Returns:
-            filter.EdgeViewPropsFilterBuilder
+            filter.EdgeViewPropsFilterBuilder:
         """
 
     @staticmethod
-    def at(time: int):
+    def at(time: int) -> filter.EdgeViewPropsFilterBuilder:
         """
         Restricts edge evaluation to a single point in time.
 
@@ -811,11 +871,11 @@ class Edge(object):
             time (int): Event time.
 
         Returns:
-            filter.EdgeViewPropsFilterBuilder
+            filter.EdgeViewPropsFilterBuilder:
         """
 
     @staticmethod
-    def before(time: int):
+    def before(time: int) -> filter.EdgeViewPropsFilterBuilder:
         """
         Restricts edge evaluation to times strictly before the given time.
 
@@ -823,65 +883,65 @@ class Edge(object):
             time (int): Upper time bound.
 
         Returns:
-            filter.EdgeViewPropsFilterBuilder
+            filter.EdgeViewPropsFilterBuilder:
         """
 
     @staticmethod
-    def dst():
+    def dst() -> filter.EdgeEndpoint:
         """
         Selects the edge **destination endpoint** for filtering.
 
         Returns:
-            filter.EdgeEndpoint
+            filter.EdgeEndpoint:
         """
 
     @staticmethod
-    def is_active():
+    def is_active() -> filter.FilterExpr:
         """
         Matches edges that have at least one event in the current view.
 
         Returns:
-            filter.FilterExpr
+            filter.FilterExpr:
         """
 
     @staticmethod
-    def is_deleted():
+    def is_deleted() -> filter.FilterExpr:
         """
         Matches edges that have been deleted.
 
         Returns:
-            filter.FilterExpr
+            filter.FilterExpr:
         """
 
     @staticmethod
-    def is_self_loop():
+    def is_self_loop() -> filter.FilterExpr:
         """
         Matches edges that are self-loops (source == destination).
 
         Returns:
-            filter.FilterExpr
+            filter.FilterExpr:
         """
 
     @staticmethod
-    def is_valid():
+    def is_valid() -> filter.FilterExpr:
         """
         Matches edges that are structurally valid in the current view.
 
         Returns:
-            filter.FilterExpr
+            filter.FilterExpr:
         """
 
     @staticmethod
-    def latest():
+    def latest() -> filter.EdgeViewPropsFilterBuilder:
         """
         Evaluates edge predicates against the latest available edge state.
 
         Returns:
-            filter.EdgeViewPropsFilterBuilder
+            filter.EdgeViewPropsFilterBuilder:
         """
 
     @staticmethod
-    def layer(layer: str):
+    def layer(layer: str) -> filter.EdgeViewPropsFilterBuilder:
         """
         Restricts evaluation to edges belonging to the given layer.
 
@@ -889,11 +949,11 @@ class Edge(object):
             layer (str): Layer name.
 
         Returns:
-            filter.EdgeViewPropsFilterBuilder
+            filter.EdgeViewPropsFilterBuilder:
         """
 
     @staticmethod
-    def layers(layers: list[str]):
+    def layers(layers: list[str]) -> filter.EdgeViewPropsFilterBuilder:
         """
         Restricts evaluation to edges belonging to any of the given layers.
 
@@ -901,11 +961,11 @@ class Edge(object):
             layers (list[str]): Layer names.
 
         Returns:
-            filter.EdgeViewPropsFilterBuilder
+            filter.EdgeViewPropsFilterBuilder:
         """
 
     @staticmethod
-    def metadata(name: str):
+    def metadata(name: str) -> filter.FilterOps:
         """
         Filters an edge metadata field by name.
 
@@ -915,11 +975,11 @@ class Edge(object):
             name (str): Metadata key.
 
         Returns:
-            filter.FilterOps
+            filter.FilterOps:
         """
 
     @staticmethod
-    def property(name: str):
+    def property(name: str) -> filter.PropertyFilterOps:
         """
         Filters an edge property by name.
 
@@ -929,11 +989,11 @@ class Edge(object):
             name (str): Property key.
 
         Returns:
-            filter.PropertyFilterOps
+            filter.PropertyFilterOps:
         """
 
     @staticmethod
-    def snapshot_at(time: int):
+    def snapshot_at(time: int) -> filter.EdgeViewPropsFilterBuilder:
         """
         Evaluates edge predicates against a snapshot of the graph at a given time.
 
@@ -941,29 +1001,29 @@ class Edge(object):
             time (int): Snapshot time.
 
         Returns:
-            filter.EdgeViewPropsFilterBuilder
+            filter.EdgeViewPropsFilterBuilder:
         """
 
     @staticmethod
-    def snapshot_latest():
+    def snapshot_latest() -> filter.EdgeViewPropsFilterBuilder:
         """
         Evaluates edge predicates against the most recent snapshot of the graph.
 
         Returns:
-            filter.EdgeViewPropsFilterBuilder
+            filter.EdgeViewPropsFilterBuilder:
         """
 
     @staticmethod
-    def src():
+    def src() -> filter.EdgeEndpoint:
         """
         Selects the edge **source endpoint** for filtering.
 
         Returns:
-            filter.EdgeEndpoint
+            filter.EdgeEndpoint:
         """
 
     @staticmethod
-    def window(start: int, end: int):
+    def window(start: int, end: int) -> filter.EdgeViewPropsFilterBuilder:
         """
         Restricts edge evaluation to the given time window.
 
@@ -974,7 +1034,7 @@ class Edge(object):
             end (int): End time.
 
         Returns:
-            filter.EdgeViewPropsFilterBuilder
+            filter.EdgeViewPropsFilterBuilder:
         """
 
 class EdgeEndpoint(object):
@@ -991,15 +1051,15 @@ class EdgeEndpoint(object):
         Edge.src().property("country") == "UK"
     """
 
-    def id(self):
+    def id(self) -> filter.EdgeEndpointIdFilter:
         """
         Selects the endpoint node ID field for filtering.
 
         Returns:
-            filter.EdgeEndpointIdFilter
+            filter.EdgeEndpointIdFilter:
         """
 
-    def metadata(self, name: str):
+    def metadata(self, name: str) -> filter.FilterOps:
         """
         Filters an endpoint node metadata field by name.
 
@@ -1009,26 +1069,26 @@ class EdgeEndpoint(object):
             name (str): Metadata key.
 
         Returns:
-            filter.FilterOps
+            filter.FilterOps:
         """
 
-    def name(self):
+    def name(self) -> filter.EdgeEndpointNameFilter:
         """
         Selects the endpoint node name field for filtering.
 
         Returns:
-            filter.EdgeEndpointNameFilter
+            filter.EdgeEndpointNameFilter:
         """
 
-    def node_type(self):
+    def node_type(self) -> filter.EdgeEndpointTypeFilter:
         """
         Selects the endpoint node type field for filtering.
 
         Returns:
-            filter.EdgeEndpointTypeFilter
+            filter.EdgeEndpointTypeFilter:
         """
 
-    def property(self, name: str):
+    def property(self, name: str) -> filter.PropertyFilterOps:
         """
         Filters an endpoint node property by name.
 
@@ -1038,7 +1098,7 @@ class EdgeEndpoint(object):
             name (str): Property key.
 
         Returns:
-            filter.PropertyFilterOps
+            filter.PropertyFilterOps:
         """
 
 class EdgeEndpointIdFilter(object):
@@ -1415,7 +1475,7 @@ class ExplodedEdge(object):
     """
 
     @staticmethod
-    def after(time: int):
+    def after(time: int) -> filter.EdgeViewPropsFilterBuilder:
         """
         Restricts exploded edge evaluation to times strictly after the given time.
 
@@ -1423,11 +1483,11 @@ class ExplodedEdge(object):
             time (int): Lower time bound.
 
         Returns:
-            filter.EdgeViewPropsFilterBuilder
+            filter.EdgeViewPropsFilterBuilder:
         """
 
     @staticmethod
-    def at(time: int):
+    def at(time: int) -> filter.EdgeViewPropsFilterBuilder:
         """
         Restricts exploded edge evaluation to a single point in time.
 
@@ -1435,11 +1495,11 @@ class ExplodedEdge(object):
             time (int): Event time.
 
         Returns:
-            filter.EdgeViewPropsFilterBuilder
+            filter.EdgeViewPropsFilterBuilder:
         """
 
     @staticmethod
-    def before(time: int):
+    def before(time: int) -> filter.EdgeViewPropsFilterBuilder:
         """
         Restricts exploded edge evaluation to times strictly before the given time.
 
@@ -1447,56 +1507,56 @@ class ExplodedEdge(object):
             time (int): Upper time bound.
 
         Returns:
-            filter.EdgeViewPropsFilterBuilder
+            filter.EdgeViewPropsFilterBuilder:
         """
 
     @staticmethod
-    def is_active():
+    def is_active() -> filter.FilterExpr:
         """
         Matches exploded edges that have at least one event in the current view.
 
         Returns:
-            filter.FilterExpr
+            filter.FilterExpr:
         """
 
     @staticmethod
-    def is_deleted():
+    def is_deleted() -> filter.FilterExpr:
         """
         Matches exploded edges that have been deleted.
 
         Returns:
-            filter.FilterExpr
+            filter.FilterExpr:
         """
 
     @staticmethod
-    def is_self_loop():
+    def is_self_loop() -> filter.FilterExpr:
         """
         Matches exploded edges that are self-loops (source == destination).
 
         Returns:
-            filter.FilterExpr
+            filter.FilterExpr:
         """
 
     @staticmethod
-    def is_valid():
+    def is_valid() -> filter.FilterExpr:
         """
         Matches exploded edges that are structurally valid in the current view.
 
         Returns:
-            filter.FilterExpr
+            filter.FilterExpr:
         """
 
     @staticmethod
-    def latest():
+    def latest() -> filter.EdgeViewPropsFilterBuilder:
         """
         Evaluates exploded edge predicates against the latest available state.
 
         Returns:
-            filter.EdgeViewPropsFilterBuilder
+            filter.EdgeViewPropsFilterBuilder:
         """
 
     @staticmethod
-    def layer(layer: str):
+    def layer(layer: str) -> filter.EdgeViewPropsFilterBuilder:
         """
         Restricts evaluation to exploded edges belonging to the given layer.
 
@@ -1504,11 +1564,11 @@ class ExplodedEdge(object):
             layer (str): Layer name.
 
         Returns:
-            filter.EdgeViewPropsFilterBuilder
+            filter.EdgeViewPropsFilterBuilder:
         """
 
     @staticmethod
-    def layers(layers: list[str]):
+    def layers(layers: list[str]) -> filter.EdgeViewPropsFilterBuilder:
         """
         Restricts evaluation to exploded edges belonging to any of the given layers.
 
@@ -1516,11 +1576,11 @@ class ExplodedEdge(object):
             layers (list[str]): Layer names.
 
         Returns:
-            filter.EdgeViewPropsFilterBuilder
+            filter.EdgeViewPropsFilterBuilder:
         """
 
     @staticmethod
-    def metadata(name: str):
+    def metadata(name: str) -> filter.FilterOps:
         """
         Filters an exploded edge metadata field by name.
 
@@ -1530,11 +1590,11 @@ class ExplodedEdge(object):
             name (str): Metadata key.
 
         Returns:
-            filter.FilterOps
+            filter.FilterOps:
         """
 
     @staticmethod
-    def property(name: str):
+    def property(name: str) -> filter.PropertyFilterOps:
         """
         Filters an exploded edge property by name.
 
@@ -1544,11 +1604,11 @@ class ExplodedEdge(object):
             name (str): Property key.
 
         Returns:
-            filter.PropertyFilterOps
+            filter.PropertyFilterOps:
         """
 
     @staticmethod
-    def snapshot_at(time: int):
+    def snapshot_at(time: int) -> filter.EdgeViewPropsFilterBuilder:
         """
         Evaluates exploded edge predicates against a snapshot of the graph at a given time.
 
@@ -1556,20 +1616,20 @@ class ExplodedEdge(object):
             time (int): Snapshot time.
 
         Returns:
-            filter.EdgeViewPropsFilterBuilder
+            filter.EdgeViewPropsFilterBuilder:
         """
 
     @staticmethod
-    def snapshot_latest():
+    def snapshot_latest() -> filter.EdgeViewPropsFilterBuilder:
         """
         Evaluates exploded edge predicates against the most recent snapshot of the graph.
 
         Returns:
-            filter.EdgeViewPropsFilterBuilder
+            filter.EdgeViewPropsFilterBuilder:
         """
 
     @staticmethod
-    def window(start: int, end: int):
+    def window(start: int, end: int) -> filter.EdgeViewPropsFilterBuilder:
         """
         Restricts exploded edge evaluation to the given time window.
 
@@ -1580,7 +1640,7 @@ class ExplodedEdge(object):
             end (int): End time.
 
         Returns:
-            filter.EdgeViewPropsFilterBuilder
+            filter.EdgeViewPropsFilterBuilder:
         """
 
 class Graph(object):
@@ -1603,7 +1663,7 @@ class Graph(object):
     """
 
     @staticmethod
-    def after(time: int):
+    def after(time: int) -> filter.ViewFilterBuilder:
         """
         Restricts evaluation to times strictly after the given time.
 
@@ -1611,11 +1671,11 @@ class Graph(object):
             time (int): Lower time bound.
 
         Returns:
-            filter.ViewFilterBuilder
+            filter.ViewFilterBuilder:
         """
 
     @staticmethod
-    def at(time: int):
+    def at(time: int) -> filter.ViewFilterBuilder:
         """
         Restricts evaluation to a single point in time.
 
@@ -1623,11 +1683,11 @@ class Graph(object):
             time (int): Event time.
 
         Returns:
-            filter.ViewFilterBuilder
+            filter.ViewFilterBuilder:
         """
 
     @staticmethod
-    def before(time: int):
+    def before(time: int) -> filter.ViewFilterBuilder:
         """
         Restricts evaluation to times strictly before the given time.
 
@@ -1635,20 +1695,20 @@ class Graph(object):
             time (int): Upper time bound.
 
         Returns:
-            filter.ViewFilterBuilder
+            filter.ViewFilterBuilder:
         """
 
     @staticmethod
-    def latest():
+    def latest() -> filter.ViewFilterBuilder:
         """
         Evaluates filters against the latest available state of the graph.
 
         Returns:
-            filter.ViewFilterBuilder
+            filter.ViewFilterBuilder:
         """
 
     @staticmethod
-    def layer(layer: str):
+    def layer(layer: str) -> filter.ViewFilterBuilder:
         """
         Restricts evaluation to a single layer.
 
@@ -1656,11 +1716,11 @@ class Graph(object):
             layer (str): Layer name.
 
         Returns:
-            filter.ViewFilterBuilder
+            filter.ViewFilterBuilder:
         """
 
     @staticmethod
-    def layers(layers: list[str]):
+    def layers(layers: list[str]) -> filter.ViewFilterBuilder:
         """
         Restricts evaluation to any of the given layers.
 
@@ -1668,11 +1728,11 @@ class Graph(object):
             layers (list[str]): Layer names.
 
         Returns:
-            filter.ViewFilterBuilder
+            filter.ViewFilterBuilder:
         """
 
     @staticmethod
-    def snapshot_at(time: int):
+    def snapshot_at(time: int) -> filter.ViewFilterBuilder:
         """
         Evaluates filters against a snapshot of the graph at a given time.
 
@@ -1680,20 +1740,20 @@ class Graph(object):
             time (int): Snapshot time.
 
         Returns:
-            filter.ViewFilterBuilder
+            filter.ViewFilterBuilder:
         """
 
     @staticmethod
-    def snapshot_latest():
+    def snapshot_latest() -> filter.ViewFilterBuilder:
         """
         Evaluates filters against the most recent snapshot of the graph.
 
         Returns:
-            filter.ViewFilterBuilder
+            filter.ViewFilterBuilder:
         """
 
     @staticmethod
-    def window(start: int, end: int):
+    def window(start: int, end: int) -> filter.ViewFilterBuilder:
         """
         Restricts evaluation to events within a time window.
 
@@ -1704,5 +1764,5 @@ class Graph(object):
             end (int): End time.
 
         Returns:
-            filter.ViewFilterBuilder
+            filter.ViewFilterBuilder:
         """
diff --git a/python/python/raphtory/gql/__init__.pyi b/python/python/raphtory/gql/__init__.pyi
new file mode 100644
index 0000000000..52dc70413d
--- /dev/null
+++ b/python/python/raphtory/gql/__init__.pyi
@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+###############################################################################
+#                                                                             #
+#                      AUTOGENERATED TYPE STUB FILE                           #
+#                                                                             #
+#    This file was automatically generated. Do not modify it directly.        #
+#    Any changes made here may be lost when the file is regenerated.          #
+#                                                                             #
+###############################################################################
+
+from typing import *
+from raphtory import *
+import raphtory.filter as filter
+from raphtory.algorithms import *
+from raphtory.vectors import *
+from raphtory.node_state import *
+from raphtory.graphql import *
+from raphtory.typing import *
+import numpy as np
+from numpy.typing import NDArray
+from datetime import datetime
+import pandas
+from pandas import DataFrame
+import pyarrow  # type: ignore[import-untyped]
+from pyarrow import DataType  # type: ignore[import-untyped]
+from os import PathLike
+from decimal import Decimal
+import networkx as nx  # type: ignore
+import pyvis  # type: ignore
+from raphtory.iterables import *
+
+__all__ = ["gql", "register_procedure", "GqlResult", "GqlRow"]
+
+def gql(graph: Any, query: Any, params=None):
+    """
+    Execute a GQL query against a Raphtory graph view.
+
+    Args:
+        graph: A Raphtory GraphView to query
+        query: A GQL query string
+
+    Returns:
+        A GqlResult object with table display, pandas conversion, and iteration.
+    """
+
+def register_procedure(
+    graph: Any, name: Any, input_params: Any, output_params: Any, data: Any
+):
+    """
+    Register a mock procedure with the cached coordinator.
+
+    Args:
+        graph: A Raphtory GraphView (needed to ensure coordinator is initialized)
+        name: Procedure name (e.g., "test.my.proc")
+        input_params: List of input parameter names
+        output_params: List of output parameter names
+        data: List of dicts, each dict maps column name -> value
+    """
+
+class GqlResult(object):
+    """GQL query result with table display, pandas conversion, and iteration."""
+
+    def __getitem__(self, key):
+        """Return self[key]."""
+
+    def __iter__(self):
+        """Implement iter(self)."""
+
+    def __len__(self):
+        """Return len(self)."""
+
+    def __repr__(self):
+        """Return repr(self)."""
+
+    def __str__(self):
+        """Return str(self)."""
+
+    @property
+    def columns(self):
+        """Get column names."""
+
+    def num_columns(self):
+        """Number of columns."""
+
+    def num_rows(self):
+        """Number of rows."""
+
+    def to_df(self):
+        """Convert to a pandas DataFrame."""
+
+class GqlRow(object):
+    """A single row from a GQL query result."""
+
+    def __getitem__(self, key):
+        """Return self[key]."""
+
+    def __repr__(self):
+        """Return repr(self)."""
+
+    def keys(self): ...
+    def to_dict(self): ...
+    def values(self): ...
diff --git a/python/python/raphtory/graph_gen/__init__.pyi b/python/python/raphtory/graph_gen/__init__.pyi
index 91b8aa18d6..84c2b739ef 100644
--- a/python/python/raphtory/graph_gen/__init__.pyi
+++ b/python/python/raphtory/graph_gen/__init__.pyi
@@ -20,20 +20,26 @@ from raphtory.algorithms import *
 from raphtory.vectors import *
 from raphtory.node_state import *
 from raphtory.graphql import *
+from raphtory.gql import *
 from raphtory.typing import *
 import numpy as np
 from numpy.typing import NDArray
 from datetime import datetime
+import pandas
 from pandas import DataFrame
+import pyarrow  # type: ignore[import-untyped]
 from pyarrow import DataType  # type: ignore[import-untyped]
 from os import PathLike
+from decimal import Decimal
 import networkx as nx  # type: ignore
 import pyvis  # type: ignore
 from raphtory.iterables import *
 
 __all__ = ["random_attachment", "ba_preferential_attachment"]
 
-def random_attachment(g: Any, nodes_to_add: Any, edges_per_step: Any, seed: Any = None):
+def random_attachment(
+    g: Any, nodes_to_add: Any, edges_per_step: Any, seed: Any = None
+) -> None:
     """
     Generates a graph using the random attachment model
 
@@ -48,12 +54,12 @@ def random_attachment(g: Any, nodes_to_add: Any, edges_per_step: Any, seed: Any
       seed: The seed used in rng, an array of length 32 containing ints (ints must have a max size of u8)
 
     Returns:
-     None
+     None:
     """
 
 def ba_preferential_attachment(
     g: Any, nodes_to_add: Any, edges_per_step: Any, seed: Any = None
-):
+) -> None:
     """
     Generates a graph using the preferential attachment model.
 
@@ -75,6 +81,5 @@ def ba_preferential_attachment(
        seed: The seed used in rng, an array of length 32 containing ints (ints must have a max size of u8)
 
     Returns:
-
-    None
+        None:
     """
diff --git a/python/python/raphtory/graph_loader/__init__.pyi b/python/python/raphtory/graph_loader/__init__.pyi
index 16af5328ff..e5901cb17f 100644
--- a/python/python/raphtory/graph_loader/__init__.pyi
+++ b/python/python/raphtory/graph_loader/__init__.pyi
@@ -20,13 +20,17 @@ from raphtory.algorithms import *
 from raphtory.vectors import *
 from raphtory.node_state import *
 from raphtory.graphql import *
+from raphtory.gql import *
 from raphtory.typing import *
 import numpy as np
 from numpy.typing import NDArray
 from datetime import datetime
+import pandas
 from pandas import DataFrame
+import pyarrow  # type: ignore[import-untyped]
 from pyarrow import DataType  # type: ignore[import-untyped]
 from os import PathLike
+from decimal import Decimal
 import networkx as nx  # type: ignore
 import pyvis  # type: ignore
 from raphtory.iterables import *
@@ -70,7 +74,7 @@ def lotr_graph_with_props() -> Graph:
     """
 
 def neo4j_movie_graph(
-    uri: str, username: str, password: str, database: str = ...
+    uri: str, username: str, password: str, database: str = "neo4j"
 ) -> Graph:
     """
     Returns the neo4j movie graph example.
@@ -79,7 +83,7 @@ def neo4j_movie_graph(
         uri (str):
         username (str):
         password (str):
-        database (str):
+        database (str): Neo4j database name. Defaults to "neo4j".
 
     Returns:
         Graph:
diff --git a/python/python/raphtory/graphql/__init__.pyi b/python/python/raphtory/graphql/__init__.pyi
index 698ea7e234..b5c21e2146 100644
--- a/python/python/raphtory/graphql/__init__.pyi
+++ b/python/python/raphtory/graphql/__init__.pyi
@@ -15,13 +15,17 @@ import raphtory.filter as filter
 from raphtory.algorithms import *
 from raphtory.vectors import *
 from raphtory.node_state import *
+from raphtory.gql import *
 from raphtory.typing import *
 import numpy as np
 from numpy.typing import NDArray
 from datetime import datetime
+import pandas
 from pandas import DataFrame
+import pyarrow  # type: ignore[import-untyped]
 from pyarrow import DataType  # type: ignore[import-untyped]
 from os import PathLike
+from decimal import Decimal
 import networkx as nx  # type: ignore
 import pyvis  # type: ignore
 from raphtory.iterables import *
@@ -44,6 +48,7 @@ __all__ = [
     "decode_graph",
     "schema",
     "cli",
+    "has_permissions_extension",
 ]
 
 class GraphServer(object):
@@ -56,13 +61,26 @@ class GraphServer(object):
         cache_tti_seconds (int, optional): the inactive time in seconds after which a graph is evicted from the cache
         log_level (str, optional): the log level for the server
         tracing (bool, optional): whether tracing should be enabled
+        tracing_level (str, optional): tracing verbosity (e.g. "ERROR", "WARN", "INFO", "DEBUG", "TRACE").
         otlp_agent_host (str, optional): OTLP agent host for tracing
         otlp_agent_port(str, optional): OTLP agent port for tracing
         otlp_tracing_service_name (str, optional): The OTLP tracing service name
         config_path (str | PathLike, optional): Path to the config file
-        auth_public_key:
-        auth_enabled_for_reads:
-        create_index:
+        auth_public_key (str, optional): Base64-encoded public key used to verify bearer tokens
+        require_auth_for_reads (bool, optional): Require auth tokens for read queries
+        create_index (bool, optional): Build a search index on startup
+        heavy_query_limit (int, optional): Maximum number of expensive traversal queries (outComponent, inComponent, edges, outEdges, inEdges, neighbours, outNeighbours, inNeighbours) allowed to run simultaneously. Extra queries are parked on a semaphore.
+        exclusive_writes (bool, optional): If True, ingestion/write operations run one at a time and block reads until complete.
+        disable_batching (bool, optional): If True, batched GraphQL requests are rejected. Prevents bypassing per-request depth/complexity limits.
+        max_batch_size (int, optional): Caps the number of queries accepted in a single batched request.
+        disable_lists (bool, optional): If True, bulk `list` endpoints on collections are disabled. Clients must use `page` instead.
+        max_page_size (int, optional): Maximum page size allowed on paged collection queries.
+        max_query_depth (int, optional): Maximum nesting depth of a query.
+        max_query_complexity (int, optional): Maximum estimated cost of a query, based on the number of fields selected.
+        max_recursive_depth (int, optional): Internal safety limit to prevent stack overflows from pathologically structured queries (async-graphql default is 32).
+        max_directives_per_field (int, optional): Maximum number of directives on any single field.
+        disable_introspection (bool, optional): If True, schema introspection is disabled entirely.
+        permissions_store_path (str | PathLike, optional): Path to the permissions store (used by the optional auth extension).
     """
 
     def __new__(
@@ -72,14 +90,26 @@ class GraphServer(object):
         cache_tti_seconds: Optional[int] = None,
         log_level: Optional[str] = None,
         tracing: Optional[bool] = None,
-        tracing_level=None,
+        tracing_level: Optional[str] = None,
         otlp_agent_host: Optional[str] = None,
         otlp_agent_port: Optional[str] = None,
         otlp_tracing_service_name: Optional[str] = None,
-        auth_public_key: Any = None,
-        auth_enabled_for_reads: Any = None,
+        auth_public_key: Optional[str] = None,
+        require_auth_for_reads: Optional[bool] = None,
         config_path: Optional[str | PathLike] = None,
-        create_index: Any = None,
+        create_index: Optional[bool] = None,
+        heavy_query_limit: Optional[int] = None,
+        exclusive_writes: Optional[bool] = None,
+        disable_batching: Optional[bool] = None,
+        max_batch_size: Optional[int] = None,
+        disable_lists: Optional[bool] = None,
+        max_page_size: Optional[int] = None,
+        max_query_depth: Optional[int] = None,
+        max_query_complexity: Optional[int] = None,
+        max_recursive_depth: Optional[int] = None,
+        max_directives_per_field: Optional[int] = None,
+        disable_introspection: Optional[bool] = None,
+        permissions_store_path: Optional[str | PathLike] = None,
     ) -> GraphServer:
         """Create and return a new object.  See help(type) for accurate signature."""
 
@@ -109,15 +139,20 @@ class GraphServer(object):
             RunningGraphServer: The running server
         """
 
-    def turn_off_index(self):
-        """Turn off index for all graphs"""
+    def turn_off_index(self) -> None:
+        """
+        Turn off index for all graphs.
+
+        Returns:
+            None:
+        """
 
     def vectorise_all_graphs(
         self,
         embeddings: OpenAIEmbeddings,
         nodes: bool | str = True,
         edges: bool | str = True,
-    ):
+    ) -> None:
         """
         Vectorise all graphs in the server working directory.
 
@@ -125,6 +160,9 @@ class GraphServer(object):
             embeddings (OpenAIEmbeddings): the embeddings to use
             nodes (bool | str): if nodes have to be embedded or not or the custom template to use if a str is provided. Defaults to True.
             edges (bool | str): if edges have to be embedded or not or the custom template to use if a str is provided. Defaults to True.
+
+        Returns:
+            None:
         """
 
     def vectorise_graph(
@@ -133,7 +171,7 @@ class GraphServer(object):
         embeddings: OpenAIEmbeddings,
         nodes: bool | str = True,
         edges: bool | str = True,
-    ):
+    ) -> None:
         """
         Vectorise the graph name in the server working directory.
 
@@ -142,6 +180,9 @@ class GraphServer(object):
             embeddings (OpenAIEmbeddings): the embeddings to use
             nodes (bool | str): if nodes have to be embedded or not or the custom template to use if a str is provided. Defaults to True.
             edges (bool | str): if edges have to be embedded or not or the custom template to use if a str is provided. Defaults to True.
+
+        Returns:
+            None:
         """
 
 class RunningGraphServer(object):
@@ -149,20 +190,20 @@ class RunningGraphServer(object):
 
     def __enter__(self): ...
     def __exit__(self, _exc_type, _exc_val, _exc_tb): ...
-    def get_client(self):
+    def get_client(self) -> RaphtoryClient:
         """
-        Get the client for the server
+        Get the client for the server.
 
         Returns:
-        RaphtoryClient: the client
+            RaphtoryClient: the client.
         """
 
-    def stop(self):
+    def stop(self) -> None:
         """
-        Stop the server and wait for it to finish
+        Stop the server and wait for it to finish.
 
         Returns:
-        None:
+            None:
         """
 
 class RaphtoryClient(object):
@@ -189,14 +230,16 @@ class RaphtoryClient(object):
             None:
         """
 
-    def create_index(self, path: Any, index_spec, in_ram: bool = True) -> None:
+    def create_index(
+        self, path: str, index_spec: RemoteIndexSpec, in_ram: bool = True
+    ) -> None:
         """
         Create Index for graph on the server at 'path'
 
         Arguments:
-            path: the path of the graph to be created
-            RemoteIndexSpec (RemoteIndexSpec): spec specifying the properties that need to be indexed
-            in_ram (bool): create index in ram
+            path (str): the path of the graph to be created
+            index_spec (RemoteIndexSpec): spec specifying the properties that need to be indexed
+            in_ram (bool): create index in ram. Defaults to True.
 
         Returns:
             None:
@@ -266,7 +309,7 @@ class RaphtoryClient(object):
         Receive graph from a path path on the server
 
         Note:
-        This downloads a copy of the graph. Modifications are not persistet to the server.
+        This downloads a copy of the graph. Modifications are not persisted to the server.
 
         Arguments:
             path (str): the path of the graph to be received
@@ -741,34 +784,48 @@ class AllPropertySpec(object):
     def __repr__(self):
         """Return repr(self)."""
 
-def encode_graph(graph):
+def encode_graph(graph: Graph | PersistentGraph) -> str:
     """
     Encode a graph using Base64 encoding
 
     Arguments:
-    graph (Graph | PersistentGraph): the graph
+        graph (Graph | PersistentGraph): the graph
 
     Returns:
-    str: the encoded graph
+        str: the encoded graph
     """
 
-def decode_graph(graph):
+def decode_graph(graph: str) -> Union[Graph, PersistentGraph]:
     """
     Decode a Base64-encoded graph
 
     Arguments:
-    graph (str): the encoded graph
+        graph (str): the encoded graph
 
     Returns:
-    Union[Graph, PersistentGraph]: the decoded graph
+        Union[Graph, PersistentGraph]: the decoded graph
     """
 
-def schema():
+def schema() -> str:
     """
     Returns the raphtory graphql server schema
 
-    Returns
-    str: Graphql schema
+    Returns:
+        str: Graphql schema
+    """
+
+def cli() -> None:
+    """
+    Run the Raphtory GraphQL CLI from Python. Uses `sys.argv` for arguments.
+
+    Returns:
+        None:
     """
 
-def cli(): ...
+def has_permissions_extension() -> bool:
+    """
+    Returns True if the permissions extension (raphtory-auth) is compiled in.
+
+    Returns:
+        bool: True if the extension is built in, False otherwise.
+    """
diff --git a/python/python/raphtory/iterables/__init__.pyi b/python/python/raphtory/iterables/__init__.pyi
index 89fce51348..982ed7cc2c 100644
--- a/python/python/raphtory/iterables/__init__.pyi
+++ b/python/python/raphtory/iterables/__init__.pyi
@@ -16,13 +16,17 @@ from raphtory.algorithms import *
 from raphtory.vectors import *
 from raphtory.node_state import *
 from raphtory.graphql import *
+from raphtory.gql import *
 from raphtory.typing import *
 import numpy as np
 from numpy.typing import NDArray
 from datetime import datetime
+import pandas
 from pandas import DataFrame
+import pyarrow  # type: ignore[import-untyped]
 from pyarrow import DataType  # type: ignore[import-untyped]
 from os import PathLike
+from decimal import Decimal
 import networkx as nx  # type: ignore
 import pyvis  # type: ignore
 
@@ -75,6 +79,16 @@ __all__ = [
     "NestedResultUtcDateTimeIterable",
     "MetadataListList",
     "PyNestedPropsIterable",
+    "PyPropValueListList",
+    "PyTemporalPropsList",
+    "PyTemporalPropsListList",
+    "PyPropHistValueList",
+    "PyPropHistValueListList",
+    "PyTemporalPropList",
+    "PyTemporalPropListList",
+    "PyPropHistItemsList",
+    "PyPropHistItemsListList",
+    "PropIterable",
 ]
 
 class NestedUtcDateTimeIterable(object):
@@ -105,7 +119,13 @@ class NestedUtcDateTimeIterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
+    def collect(self) -> list[list]:
+        """
+        Materialise the nested iterable as a list of lists.
+
+        Returns:
+            list[list]:
+        """
 
 class NestedGIDIterable(object):
     def __eq__(self, value):
@@ -135,9 +155,29 @@ class NestedGIDIterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
-    def max(self): ...
-    def min(self): ...
+    def collect(self) -> list[list]:
+        """
+        Materialise the nested iterable as a list of lists.
+
+        Returns:
+            list[list]:
+        """
+
+    def max(self) -> Any:
+        """
+        Per-row maximum value (or None for empty rows).
+
+        Returns:
+            Any:
+        """
+
+    def min(self) -> Any:
+        """
+        Per-row minimum value (or None for empty rows).
+
+        Returns:
+            Any:
+        """
 
 class GIDIterable(object):
     def __eq__(self, value):
@@ -167,9 +207,29 @@ class GIDIterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
-    def max(self): ...
-    def min(self): ...
+    def collect(self) -> list:
+        """
+        Materialise the iterable as a Python list.
+
+        Returns:
+            list:
+        """
+
+    def max(self) -> Any:
+        """
+        Maximum value in the iterable, or `None` if empty.
+
+        Returns:
+            Any:
+        """
+
+    def min(self) -> Any:
+        """
+        Minimum value in the iterable, or `None` if empty.
+
+        Returns:
+            Any:
+        """
 
 class StringIterable(object):
     def __eq__(self, value):
@@ -199,7 +259,13 @@ class StringIterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
+    def collect(self) -> list:
+        """
+        Materialise the iterable as a Python list.
+
+        Returns:
+            list:
+        """
 
 class OptionArcStringIterable(object):
     def __eq__(self, value):
@@ -229,7 +295,13 @@ class OptionArcStringIterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
+    def collect(self) -> list:
+        """
+        Materialise the iterable as a Python list.
+
+        Returns:
+            list:
+        """
 
 class UsizeIterable(object):
     def __eq__(self, value):
@@ -259,11 +331,45 @@ class UsizeIterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
-    def max(self): ...
-    def mean(self): ...
-    def min(self): ...
-    def sum(self): ...
+    def collect(self) -> list:
+        """
+        Materialise the iterable as a Python list.
+
+        Returns:
+            list:
+        """
+
+    def max(self) -> Any:
+        """
+        Maximum value in the iterable, or `None` if empty.
+
+        Returns:
+            Any:
+        """
+
+    def mean(self) -> float:
+        """
+        Mean of all values in the iterable.
+
+        Returns:
+            float:
+        """
+
+    def min(self) -> Any:
+        """
+        Minimum value in the iterable, or `None` if empty.
+
+        Returns:
+            Any:
+        """
+
+    def sum(self) -> Any:
+        """
+        Sum of all values in the iterable.
+
+        Returns:
+            Any:
+        """
 
 class OptionI64Iterable(object):
     def __eq__(self, value):
@@ -293,9 +399,29 @@ class OptionI64Iterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
-    def max(self): ...
-    def min(self): ...
+    def collect(self) -> list:
+        """
+        Materialise the iterable as a Python list.
+
+        Returns:
+            list:
+        """
+
+    def max(self) -> Any:
+        """
+        Maximum value in the iterable, or `None` if empty.
+
+        Returns:
+            Any:
+        """
+
+    def min(self) -> Any:
+        """
+        Minimum value in the iterable, or `None` if empty.
+
+        Returns:
+            Any:
+        """
 
 class NestedOptionArcStringIterable(object):
     def __eq__(self, value):
@@ -325,7 +451,13 @@ class NestedOptionArcStringIterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
+    def collect(self) -> list[list]:
+        """
+        Materialise the nested iterable as a list of lists.
+
+        Returns:
+            list[list]:
+        """
 
 class NestedStringIterable(object):
     def __eq__(self, value):
@@ -355,7 +487,13 @@ class NestedStringIterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
+    def collect(self) -> list[list]:
+        """
+        Materialise the nested iterable as a list of lists.
+
+        Returns:
+            list[list]:
+        """
 
 class NestedOptionI64Iterable(object):
     def __eq__(self, value):
@@ -385,9 +523,29 @@ class NestedOptionI64Iterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
-    def max(self): ...
-    def min(self): ...
+    def collect(self) -> list[list]:
+        """
+        Materialise the nested iterable as a list of lists.
+
+        Returns:
+            list[list]:
+        """
+
+    def max(self) -> Any:
+        """
+        Per-row maximum value (or None for empty rows).
+
+        Returns:
+            Any:
+        """
+
+    def min(self) -> Any:
+        """
+        Per-row minimum value (or None for empty rows).
+
+        Returns:
+            Any:
+        """
 
 class NestedI64VecIterable(object):
     def __eq__(self, value):
@@ -417,7 +575,13 @@ class NestedI64VecIterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
+    def collect(self) -> list[list]:
+        """
+        Materialise the nested iterable as a list of lists.
+
+        Returns:
+            list[list]:
+        """
 
 class NestedUsizeIterable(object):
     def __eq__(self, value):
@@ -447,11 +611,45 @@ class NestedUsizeIterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
-    def max(self): ...
-    def mean(self): ...
-    def min(self): ...
-    def sum(self): ...
+    def collect(self) -> list[list]:
+        """
+        Materialise the nested iterable as a list of lists.
+
+        Returns:
+            list[list]:
+        """
+
+    def max(self) -> Any:
+        """
+        Per-row maximum value (or None for empty rows).
+
+        Returns:
+            Any:
+        """
+
+    def mean(self) -> Any:
+        """
+        Per-row mean of values (one entry per outer row).
+
+        Returns:
+            Any:
+        """
+
+    def min(self) -> Any:
+        """
+        Per-row minimum value (or None for empty rows).
+
+        Returns:
+            Any:
+        """
+
+    def sum(self) -> Any:
+        """
+        Per-row sum of values (one entry per outer row).
+
+        Returns:
+            Any:
+        """
 
 class BoolIterable(object):
     def __eq__(self, value):
@@ -481,7 +679,13 @@ class BoolIterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
+    def collect(self) -> list:
+        """
+        Materialise the iterable as a Python list.
+
+        Returns:
+            list:
+        """
 
 class ArcStringIterable(object):
     def __iter__(self):
@@ -493,7 +697,13 @@ class ArcStringIterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
+    def collect(self) -> list:
+        """
+        Materialise the iterable as a Python list.
+
+        Returns:
+            list:
+        """
 
 class NestedVecUtcDateTimeIterable(object):
     def __eq__(self, value):
@@ -523,7 +733,13 @@ class NestedVecUtcDateTimeIterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
+    def collect(self) -> list[list]:
+        """
+        Materialise the nested iterable as a list of lists.
+
+        Returns:
+            list[list]:
+        """
 
 class OptionVecUtcDateTimeIterable(object):
     def __eq__(self, value):
@@ -553,7 +769,13 @@ class OptionVecUtcDateTimeIterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
+    def collect(self) -> list:
+        """
+        Materialise the iterable as a Python list.
+
+        Returns:
+            list:
+        """
 
 class GIDGIDIterable(object):
     def __eq__(self, value):
@@ -583,9 +805,29 @@ class GIDGIDIterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
-    def max(self): ...
-    def min(self): ...
+    def collect(self) -> list:
+        """
+        Materialise the iterable as a Python list.
+
+        Returns:
+            list:
+        """
+
+    def max(self) -> Any:
+        """
+        Maximum value in the iterable, or `None` if empty.
+
+        Returns:
+            Any:
+        """
+
+    def min(self) -> Any:
+        """
+        Minimum value in the iterable, or `None` if empty.
+
+        Returns:
+            Any:
+        """
 
 class NestedGIDGIDIterable(object):
     def __eq__(self, value):
@@ -615,9 +857,29 @@ class NestedGIDGIDIterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
-    def max(self): ...
-    def min(self): ...
+    def collect(self) -> list[list]:
+        """
+        Materialise the nested iterable as a list of lists.
+
+        Returns:
+            list[list]:
+        """
+
+    def max(self) -> Any:
+        """
+        Per-row maximum value (or None for empty rows).
+
+        Returns:
+            Any:
+        """
+
+    def min(self) -> Any:
+        """
+        Per-row minimum value (or None for empty rows).
+
+        Returns:
+            Any:
+        """
 
 class NestedBoolIterable(object):
     def __eq__(self, value):
@@ -647,7 +909,13 @@ class NestedBoolIterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
+    def collect(self) -> list[list]:
+        """
+        Materialise the nested iterable as a list of lists.
+
+        Returns:
+            list[list]:
+        """
 
 class U64Iterable(object):
     def __eq__(self, value):
@@ -677,11 +945,45 @@ class U64Iterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
-    def max(self): ...
-    def mean(self): ...
-    def min(self): ...
-    def sum(self): ...
+    def collect(self) -> list:
+        """
+        Materialise the iterable as a Python list.
+
+        Returns:
+            list:
+        """
+
+    def max(self) -> Any:
+        """
+        Maximum value in the iterable, or `None` if empty.
+
+        Returns:
+            Any:
+        """
+
+    def mean(self) -> float:
+        """
+        Mean of all values in the iterable.
+
+        Returns:
+            float:
+        """
+
+    def min(self) -> Any:
+        """
+        Minimum value in the iterable, or `None` if empty.
+
+        Returns:
+            Any:
+        """
+
+    def sum(self) -> Any:
+        """
+        Sum of all values in the iterable.
+
+        Returns:
+            Any:
+        """
 
 class OptionUtcDateTimeIterable(object):
     def __eq__(self, value):
@@ -711,7 +1013,13 @@ class OptionUtcDateTimeIterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
+    def collect(self) -> list:
+        """
+        Materialise the iterable as a Python list.
+
+        Returns:
+            list:
+        """
 
 class ArcStringVecIterable(object):
     def __eq__(self, value):
@@ -741,7 +1049,13 @@ class ArcStringVecIterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
+    def collect(self) -> list:
+        """
+        Materialise the iterable as a Python list.
+
+        Returns:
+            list:
+        """
 
 class NestedArcStringVecIterable(object):
     def __eq__(self, value):
@@ -771,7 +1085,13 @@ class NestedArcStringVecIterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
+    def collect(self) -> list[list]:
+        """
+        Materialise the nested iterable as a list of lists.
+
+        Returns:
+            list[list]:
+        """
 
 class NestedEventTimeIterable(object):
     def __eq__(self, value):
@@ -801,7 +1121,14 @@ class NestedEventTimeIterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
+    def collect(self) -> list[list]:
+        """
+        Materialise the nested iterable as a list of lists.
+
+        Returns:
+            list[list]:
+        """
+
     @property
     def dt(self) -> NestedResultUtcDateTimeIterable:
         """
@@ -823,8 +1150,22 @@ class NestedEventTimeIterable(object):
             NestedUsizeIterable: Nested iterable of event ids associated to each EventTime.
         """
 
-    def max(self): ...
-    def min(self): ...
+    def max(self) -> Any:
+        """
+        Per-row maximum value (or None for empty rows).
+
+        Returns:
+            Any:
+        """
+
+    def min(self) -> Any:
+        """
+        Per-row minimum value (or None for empty rows).
+
+        Returns:
+            Any:
+        """
+
     @property
     def t(self) -> NestedI64Iterable:
         """
@@ -844,7 +1185,13 @@ class NestedArcStringIterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
+    def collect(self) -> list[list]:
+        """
+        Materialise the nested iterable as a list of lists.
+
+        Returns:
+            list[list]:
+        """
 
 class NestedOptionEventTimeIterable(object):
     def __eq__(self, value):
@@ -874,7 +1221,14 @@ class NestedOptionEventTimeIterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
+    def collect(self) -> list[list]:
+        """
+        Materialise the nested iterable as a list of lists.
+
+        Returns:
+            list[list]:
+        """
+
     @property
     def dt(self) -> NestedResultOptionUtcDateTimeIterable:
         """
@@ -896,8 +1250,22 @@ class NestedOptionEventTimeIterable(object):
             NestedOptionUsizeIterable: Nested iterable of event ids associated to each EventTime, if available.
         """
 
-    def max(self): ...
-    def min(self): ...
+    def max(self) -> Any:
+        """
+        Per-row maximum value (or None for empty rows).
+
+        Returns:
+            Any:
+        """
+
+    def min(self) -> Any:
+        """
+        Per-row minimum value (or None for empty rows).
+
+        Returns:
+            Any:
+        """
+
     @property
     def t(self) -> NestedOptionI64Iterable:
         """
@@ -997,7 +1365,14 @@ class EventTimeIterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
+    def collect(self) -> list:
+        """
+        Materialise the iterable as a Python list.
+
+        Returns:
+            list:
+        """
+
     @property
     def dt(self) -> ResultUtcDateTimeIterable:
         """
@@ -1019,18 +1394,32 @@ class EventTimeIterable(object):
             UsizeIterable: Iterable of event ids associated to each EventTime.
         """
 
-    def max(self): ...
-    def min(self): ...
-    @property
-    def t(self) -> I64Iterable:
+    def max(self) -> Any:
         """
-        Change this Iterable of EventTime into an Iterable of corresponding Unix timestamps in milliseconds.
+        Maximum value in the iterable, or `None` if empty.
 
         Returns:
-            I64Iterable: Iterable of millisecond timestamps since the Unix epoch for each EventTime.
+            Any:
         """
 
-class OptionEventTimeIterable(object):
+    def min(self) -> Any:
+        """
+        Minimum value in the iterable, or `None` if empty.
+
+        Returns:
+            Any:
+        """
+
+    @property
+    def t(self) -> I64Iterable:
+        """
+        Change this Iterable of EventTime into an Iterable of corresponding Unix timestamps in milliseconds.
+
+        Returns:
+            I64Iterable: Iterable of millisecond timestamps since the Unix epoch for each EventTime.
+        """
+
+class OptionEventTimeIterable(object):
     def __eq__(self, value):
         """Return self==value."""
 
@@ -1058,7 +1447,14 @@ class OptionEventTimeIterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
+    def collect(self) -> list:
+        """
+        Materialise the iterable as a Python list.
+
+        Returns:
+            list:
+        """
+
     @property
     def dt(self) -> ResultOptionUtcDateTimeIterable:
         """
@@ -1080,8 +1476,22 @@ class OptionEventTimeIterable(object):
             OptionUsizeIterable: Iterable of event ids associated to each EventTime, if available.
         """
 
-    def max(self): ...
-    def min(self): ...
+    def max(self) -> Any:
+        """
+        Maximum value in the iterable, or `None` if empty.
+
+        Returns:
+            Any:
+        """
+
+    def min(self) -> Any:
+        """
+        Minimum value in the iterable, or `None` if empty.
+
+        Returns:
+            Any:
+        """
+
     @property
     def t(self) -> OptionI64Iterable:
         """
@@ -1280,9 +1690,29 @@ class OptionUsizeIterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
-    def max(self): ...
-    def min(self): ...
+    def collect(self) -> list:
+        """
+        Materialise the iterable as a Python list.
+
+        Returns:
+            list:
+        """
+
+    def max(self) -> Any:
+        """
+        Maximum value in the iterable, or `None` if empty.
+
+        Returns:
+            Any:
+        """
+
+    def min(self) -> Any:
+        """
+        Minimum value in the iterable, or `None` if empty.
+
+        Returns:
+            Any:
+        """
 
 class ResultOptionUtcDateTimeIterable(object):
     def __iter__(self):
@@ -1294,7 +1724,13 @@ class ResultOptionUtcDateTimeIterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
+    def collect(self) -> list[Optional[datetime]]:
+        """
+        Materialise the iterable as a list of optional datetimes, raising if any element produced an error.
+
+        Returns:
+            list[Optional[datetime]]: one entry per element (None where absent).
+        """
 
 class I64Iterable(object):
     def __eq__(self, value):
@@ -1324,11 +1760,45 @@ class I64Iterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
-    def max(self): ...
-    def mean(self): ...
-    def min(self): ...
-    def sum(self): ...
+    def collect(self) -> list:
+        """
+        Materialise the iterable as a Python list.
+
+        Returns:
+            list:
+        """
+
+    def max(self) -> Any:
+        """
+        Maximum value in the iterable, or `None` if empty.
+
+        Returns:
+            Any:
+        """
+
+    def mean(self) -> float:
+        """
+        Mean of all values in the iterable.
+
+        Returns:
+            float:
+        """
+
+    def min(self) -> Any:
+        """
+        Minimum value in the iterable, or `None` if empty.
+
+        Returns:
+            Any:
+        """
+
+    def sum(self) -> Any:
+        """
+        Sum of all values in the iterable.
+
+        Returns:
+            Any:
+        """
 
 class ResultUtcDateTimeIterable(object):
     def __iter__(self):
@@ -1340,7 +1810,13 @@ class ResultUtcDateTimeIterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
+    def collect(self) -> list[datetime]:
+        """
+        Materialise the iterable as a list of datetimes, raising if any element produced an error.
+
+        Returns:
+            list[datetime]: one datetime per element.
+        """
 
 class NestedHistoryTimestampIterable(object):
     def __iter__(self):
@@ -1528,9 +2004,29 @@ class NestedOptionUsizeIterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
-    def max(self): ...
-    def min(self): ...
+    def collect(self) -> list[list]:
+        """
+        Materialise the nested iterable as a list of lists.
+
+        Returns:
+            list[list]:
+        """
+
+    def max(self) -> Any:
+        """
+        Per-row maximum value (or None for empty rows).
+
+        Returns:
+            Any:
+        """
+
+    def min(self) -> Any:
+        """
+        Per-row minimum value (or None for empty rows).
+
+        Returns:
+            Any:
+        """
 
 class NestedResultOptionUtcDateTimeIterable(object):
     def __iter__(self):
@@ -1542,7 +2038,13 @@ class NestedResultOptionUtcDateTimeIterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
+    def collect(self) -> list[list[Optional[datetime]]]:
+        """
+        Materialise the iterable as a nested list of optional datetimes, raising if any element produced an error.
+
+        Returns:
+            list[list[Optional[datetime]]]: one inner list per outer element (entries are None where absent).
+        """
 
 class NestedI64Iterable(object):
     def __eq__(self, value):
@@ -1572,11 +2074,45 @@ class NestedI64Iterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
-    def max(self): ...
-    def mean(self): ...
-    def min(self): ...
-    def sum(self): ...
+    def collect(self) -> list[list]:
+        """
+        Materialise the nested iterable as a list of lists.
+
+        Returns:
+            list[list]:
+        """
+
+    def max(self) -> Any:
+        """
+        Per-row maximum value (or None for empty rows).
+
+        Returns:
+            Any:
+        """
+
+    def mean(self) -> Any:
+        """
+        Per-row mean of values (one entry per outer row).
+
+        Returns:
+            Any:
+        """
+
+    def min(self) -> Any:
+        """
+        Per-row minimum value (or None for empty rows).
+
+        Returns:
+            Any:
+        """
+
+    def sum(self) -> Any:
+        """
+        Per-row sum of values (one entry per outer row).
+
+        Returns:
+            Any:
+        """
 
 class NestedResultUtcDateTimeIterable(object):
     def __iter__(self):
@@ -1588,7 +2124,13 @@ class NestedResultUtcDateTimeIterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
+    def collect(self) -> list[list[datetime]]:
+        """
+        Materialise the iterable as a nested list of datetimes, raising if any element produced an error.
+
+        Returns:
+            list[list[datetime]]: one inner list per outer element.
+        """
 
 class MetadataListList(object):
     def __contains__(self, key):
@@ -1618,11 +2160,48 @@ class MetadataListList(object):
     def __ne__(self, value):
         """Return self!=value."""
 
-    def as_dict(self): ...
-    def get(self, key): ...
-    def items(self): ...
-    def keys(self): ...
-    def values(self): ...
+    def as_dict(self) -> dict[str, list]:
+        """
+        Materialise as a dict mapping each key to a list of value lists.
+
+        Returns:
+            dict[str, list]:
+        """
+
+    def get(self, key: str) -> Optional[PyPropValueListList]:
+        """
+        Look up the metadata for `key` across all entities.
+
+        Arguments:
+            key (str): metadata key.
+
+        Returns:
+            Optional[PyPropValueListList]:
+        """
+
+    def items(self) -> list[tuple[str, PyPropValueListList]]:
+        """
+        Pairs of `(key, value list-of-lists)` for every metadata key.
+
+        Returns:
+            list[tuple[str, PyPropValueListList]]:
+        """
+
+    def keys(self) -> list[str]:
+        """
+        Metadata keys present across the underlying entities.
+
+        Returns:
+            list[str]:
+        """
+
+    def values(self) -> list[PyPropValueListList]:
+        """
+        Per-key list of value lists.
+
+        Returns:
+            list[PyPropValueListList]:
+        """
 
 class PyNestedPropsIterable(object):
     def __contains__(self, key):
@@ -1660,7 +2239,7 @@ class PyNestedPropsIterable(object):
             dict[str, List[List[PropValue]]]:
         """
 
-    def get(self, key: str):
+    def get(self, key: str) -> Optional[PyPropValueListList]:
         """
         Get property value.
 
@@ -1668,7 +2247,7 @@ class PyNestedPropsIterable(object):
             key (str): the name of the property.
 
         Returns:
-            PyPropValueListList:
+            Optional[PyPropValueListList]:
         """
 
     def items(self) -> list[Tuple[str, List[PropValue]]]:
@@ -1679,21 +2258,21 @@ class PyNestedPropsIterable(object):
             list[Tuple[str, List[PropValue]]]:
         """
 
-    def keys(self):
+    def keys(self) -> list[str]:
         """
         Get the names for all properties.
 
         Returns:
-            List[Str]:
+            list[str]:
         """
 
     @property
-    def temporal(self):
+    def temporal(self) -> list[list[TemporalProperty]]:
         """
         Get a view of the temporal properties only.
 
         Returns:
-            List[List[temporalprop]]:
+            list[list[TemporalProperty]]:
         """
 
     def values(self) -> list[list[list[PropValue]]]:
@@ -1704,3 +2283,793 @@ class PyNestedPropsIterable(object):
         Returns:
             list[list[list[PropValue]]]:
         """
+
+class PyPropValueListList(object):
+    def __eq__(self, value):
+        """Return self==value."""
+
+    def __ge__(self, value):
+        """Return self>=value."""
+
+    def __gt__(self, value):
+        """Return self>value."""
+
+    def __iter__(self):
+        """Implement iter(self)."""
+
+    def __le__(self, value):
+        """Return self<=value."""
+
+    def __len__(self):
+        """Return len(self)."""
+
+    def __lt__(self, value):
+        """Return self<value."""
+
+    def __ne__(self, value):
+        """Return self!=value."""
+
+    def __repr__(self):
+        """Return repr(self)."""
+
+    def average(self) -> list[PropValue]:
+        """
+        Compute the average of all property values. Alias for mean().
+
+        Returns:
+            list[PropValue]:
+        """
+
+    def collect(self) -> list[list]:
+        """
+        Materialise the nested iterable as a list of lists.
+
+        Returns:
+            list[list]:
+        """
+
+    def count(self) -> UsizeIterable:
+        """
+        Number of properties (or rows of properties).
+
+        Returns:
+            UsizeIterable:
+        """
+
+    def drop_none(self) -> PyPropValueListList:
+        """
+        Drop missing entries from each row.
+
+        Returns:
+            PyPropValueListList:
+        """
+
+    def flatten(self) -> PyPropValueList:
+        """
+        Flatten the nested iterable into a single list of values.
+
+        Returns:
+            PyPropValueList:
+        """
+
+    def max(self) -> list[PropValue]:
+        """
+        Find the maximum property value and its associated time.
+
+        Returns:
+            list[PropValue]:
+        """
+
+    def mean(self) -> PyPropValueList:
+        """
+        Mean property value across each row.
+
+        Returns:
+            PyPropValueList:
+        """
+
+    def median(self) -> PyPropValueList:
+        """
+        Median property value across each row.
+
+        Returns:
+            PyPropValueList:
+        """
+
+    def min(self) -> list[PropValue]:
+        """
+        Min property value.
+
+        Returns:
+            list[PropValue]:
+        """
+
+    def sum(self) -> list[PropValue]:
+        """
+        Sum of property values.
+
+        Returns:
+            list[PropValue]:
+        """
+
+class PyTemporalPropsList(object):
+    def __contains__(self, key):
+        """Return bool(key in self)."""
+
+    def __eq__(self, value):
+        """Return self==value."""
+
+    def __ge__(self, value):
+        """Return self>=value."""
+
+    def __getitem__(self, key):
+        """Return self[key]."""
+
+    def __gt__(self, value):
+        """Return self>value."""
+
+    def __iter__(self):
+        """Implement iter(self)."""
+
+    def __le__(self, value):
+        """Return self<=value."""
+
+    def __lt__(self, value):
+        """Return self<value."""
+
+    def __ne__(self, value):
+        """Return self!=value."""
+
+    def get(self, key: str) -> Optional[PyTemporalPropList]:
+        """
+        Look up a temporal property by key.
+
+        Arguments:
+            key (str): property key.
+
+        Returns:
+            Optional[PyTemporalPropList]:
+        """
+
+    def histories(self) -> dict[str, PyPropHistItemsList]:
+        """
+        Full update history of each property across the underlying entities.
+
+        Returns:
+            dict[str, PyPropHistItemsList]:
+        """
+
+    def items(self) -> list[tuple[str, PyTemporalPropList]]:
+        """
+        Pairs of `(key, temporal property list)` for every property key.
+
+        Returns:
+            list[tuple[str, PyTemporalPropList]]:
+        """
+
+    def keys(self) -> list[str]:
+        """
+        Property keys present across the underlying entities.
+
+        Returns:
+            list[str]:
+        """
+
+    def latest(self) -> dict[str, PyPropValueList]:
+        """
+        Latest value of each property across the underlying entities.
+
+        Returns:
+            dict[str, PyPropValueList]:
+        """
+
+    def values(self) -> list[PyTemporalPropList]:
+        """
+        Per-key list of temporal property views.
+
+        Returns:
+            list[PyTemporalPropList]:
+        """
+
+class PyTemporalPropsListList(object):
+    def __contains__(self, key):
+        """Return bool(key in self)."""
+
+    def __eq__(self, value):
+        """Return self==value."""
+
+    def __ge__(self, value):
+        """Return self>=value."""
+
+    def __getitem__(self, key):
+        """Return self[key]."""
+
+    def __gt__(self, value):
+        """Return self>value."""
+
+    def __iter__(self):
+        """Implement iter(self)."""
+
+    def __le__(self, value):
+        """Return self<=value."""
+
+    def __lt__(self, value):
+        """Return self<value."""
+
+    def __ne__(self, value):
+        """Return self!=value."""
+
+    def get(self, key: str) -> Optional[PyTemporalPropListList]:
+        """
+        Look up a nested temporal property by key.
+
+        Arguments:
+            key (str): property key.
+
+        Returns:
+            Optional[PyTemporalPropListList]:
+        """
+
+    def histories(self) -> dict[str, PyPropHistItemsListList]:
+        """
+        Full update history of each property across the nested entities.
+
+        Returns:
+            dict[str, PyPropHistItemsListList]:
+        """
+
+    def items(self) -> list[tuple[str, PyTemporalPropListList]]:
+        """
+        Pairs of `(key, nested temporal property list)` for every property key.
+
+        Returns:
+            list[tuple[str, PyTemporalPropListList]]:
+        """
+
+    def keys(self) -> list[str]:
+        """
+        Property keys present across the underlying entities.
+
+        Returns:
+            list[str]:
+        """
+
+    def latest(self) -> dict[str, PyPropValueListList]:
+        """
+        Latest value of each property across the nested entities.
+
+        Returns:
+            dict[str, PyPropValueListList]:
+        """
+
+    def values(self) -> list[PyTemporalPropListList]:
+        """
+        Per-key list of nested temporal property views.
+
+        Returns:
+            list[PyTemporalPropListList]:
+        """
+
+class PyPropHistValueList(object):
+    def __eq__(self, value):
+        """Return self==value."""
+
+    def __ge__(self, value):
+        """Return self>=value."""
+
+    def __gt__(self, value):
+        """Return self>value."""
+
+    def __iter__(self):
+        """Implement iter(self)."""
+
+    def __le__(self, value):
+        """Return self<=value."""
+
+    def __len__(self):
+        """Return len(self)."""
+
+    def __lt__(self, value):
+        """Return self<value."""
+
+    def __ne__(self, value):
+        """Return self!=value."""
+
+    def __repr__(self):
+        """Return repr(self)."""
+
+    def average(self) -> list[PropValue]:
+        """
+        Compute the average of all property values. Alias for mean().
+
+        Returns:
+            list[PropValue]:
+        """
+
+    def collect(self) -> list:
+        """
+        Materialise the iterable as a Python list.
+
+        Returns:
+            list:
+        """
+
+    def count(self) -> UsizeIterable:
+        """
+        Number of properties (or rows of properties).
+
+        Returns:
+            UsizeIterable:
+        """
+
+    def flatten(self) -> PropIterable:
+        """
+        Flatten the per-row history values into a single iterable of values.
+
+        Returns:
+            PropIterable:
+        """
+
+    def max(self) -> list[PropValue]:
+        """
+        Find the maximum property value and its associated time.
+
+        Returns:
+            list[PropValue]:
+        """
+
+    def mean(self) -> list[PropValue]:
+        """
+        Compute the mean of all property values.
+
+        Returns:
+            list[PropValue]: The mean of each property values, or None if count is zero.
+        """
+
+    def median(self) -> PyPropValueList:
+        """
+        Median property value of each row.
+
+        Returns:
+            PyPropValueList:
+        """
+
+    def min(self) -> list[PropValue]:
+        """
+        Min property value.
+
+        Returns:
+            list[PropValue]:
+        """
+
+    def sum(self) -> list[PropValue]:
+        """
+        Sum of property values.
+
+        Returns:
+            list[PropValue]:
+        """
+
+class PyPropHistValueListList(object):
+    def __eq__(self, value):
+        """Return self==value."""
+
+    def __ge__(self, value):
+        """Return self>=value."""
+
+    def __gt__(self, value):
+        """Return self>value."""
+
+    def __iter__(self):
+        """Implement iter(self)."""
+
+    def __le__(self, value):
+        """Return self<=value."""
+
+    def __len__(self):
+        """Return len(self)."""
+
+    def __lt__(self, value):
+        """Return self<value."""
+
+    def __ne__(self, value):
+        """Return self!=value."""
+
+    def __repr__(self):
+        """Return repr(self)."""
+
+    def collect(self) -> list[list]:
+        """
+        Materialise the nested iterable as a list of lists.
+
+        Returns:
+            list[list]:
+        """
+
+    def count(self) -> NestedUsizeIterable:
+        """
+        Number of properties (or rows of properties).
+
+        Returns:
+            NestedUsizeIterable:
+        """
+
+    def flatten(self) -> PyPropHistValueList:
+        """
+        Flatten the nested history-values list to a single history-values list.
+
+        Returns:
+            PyPropHistValueList:
+        """
+
+    def max(self) -> list[list[PropValue]]:
+        """
+        Find the maximum property value and its associated time.
+
+        Returns:
+            list[list[PropValue]]:
+        """
+
+    def mean(self) -> PyPropValueListList:
+        """
+        Mean property value across each row.
+
+        Returns:
+            PyPropValueListList:
+        """
+
+    def median(self) -> list[list[PropValue]]:
+        """
+        Median
+
+         Returns:
+            list[list[PropValue]]:
+        """
+
+    def min(self) -> list[list[PropValue]]:
+        """
+        Min property value.
+
+        Returns:
+            list[list[PropValue]]:
+        """
+
+    def sum(self) -> list[list[PropValue]]:
+        """
+        Sum of property values.
+
+        Returns:
+            list[list[PropValue]]:
+        """
+
+class PyTemporalPropList(object):
+    def __eq__(self, value):
+        """Return self==value."""
+
+    def __ge__(self, value):
+        """Return self>=value."""
+
+    def __gt__(self, value):
+        """Return self>value."""
+
+    def __iter__(self):
+        """Implement iter(self)."""
+
+    def __le__(self, value):
+        """Return self<=value."""
+
+    def __len__(self):
+        """Return len(self)."""
+
+    def __lt__(self, value):
+        """Return self<value."""
+
+    def __ne__(self, value):
+        """Return self!=value."""
+
+    def __repr__(self):
+        """Return repr(self)."""
+
+    def at(self, t: TimeInput) -> PyPropValueList:
+        """
+        Value of each entity's property at the given time (latest update at or before `t`).
+
+        Arguments:
+            t (TimeInput): the time at which to evaluate the property.
+
+        Returns:
+            PyPropValueList:
+        """
+
+    def collect(self) -> list:
+        """
+        Materialise the iterable as a Python list.
+
+        Returns:
+            list:
+        """
+
+    @property
+    def history(self) -> HistoryIterable:
+        """
+        Update history (one history per underlying entity).
+
+        Returns:
+            HistoryIterable:
+        """
+
+    def items(self) -> PyPropHistItemsList:
+        """
+        Per-entity list of `(time, value)` pairs across each entity's history.
+
+        Returns:
+            PyPropHistItemsList:
+        """
+
+    def value(self) -> PyPropValueList:
+        """
+        Latest value of each entity's property.
+
+        Returns:
+            PyPropValueList:
+        """
+
+    def values(self) -> PyPropHistValueList:
+        """
+        Per-entity list of property values across each entity's history.
+
+        Returns:
+            PyPropHistValueList:
+        """
+
+class PyTemporalPropListList(object):
+    def __eq__(self, value):
+        """Return self==value."""
+
+    def __ge__(self, value):
+        """Return self>=value."""
+
+    def __gt__(self, value):
+        """Return self>value."""
+
+    def __iter__(self):
+        """Implement iter(self)."""
+
+    def __le__(self, value):
+        """Return self<=value."""
+
+    def __len__(self):
+        """Return len(self)."""
+
+    def __lt__(self, value):
+        """Return self<value."""
+
+    def __ne__(self, value):
+        """Return self!=value."""
+
+    def __repr__(self):
+        """Return repr(self)."""
+
+    def at(self, t: TimeInput) -> PyPropValueListList:
+        """
+        Value of each inner entity's property at the given time.
+
+        Arguments:
+            t (TimeInput): the time at which to evaluate the property.
+
+        Returns:
+            PyPropValueListList:
+        """
+
+    def collect(self) -> list[list]:
+        """
+        Materialise the nested iterable as a list of lists.
+
+        Returns:
+            list[list]:
+        """
+
+    def flatten(self) -> PyTemporalPropList:
+        """
+        Flatten the nested temporal property list to a single list of temporal properties.
+
+        Returns:
+            PyTemporalPropList:
+        """
+
+    @property
+    def history(self) -> NestedHistoryIterable:
+        """
+        Update history (per outer entity, per inner entity).
+
+        Returns:
+            NestedHistoryIterable:
+        """
+
+    def items(self) -> PyPropHistItemsListList:
+        """
+        Nested list of `(time, value)` pairs across each inner entity's history.
+
+        Returns:
+            PyPropHistItemsListList:
+        """
+
+    def value(self) -> PyPropValueListList:
+        """
+        Latest value of each inner entity's property.
+
+        Returns:
+            PyPropValueListList:
+        """
+
+    def values(self) -> PyPropHistValueListList:
+        """
+        Nested list of property values across each inner entity's history.
+
+        Returns:
+            PyPropHistValueListList:
+        """
+
+class PyPropHistItemsList(object):
+    def __eq__(self, value):
+        """Return self==value."""
+
+    def __ge__(self, value):
+        """Return self>=value."""
+
+    def __gt__(self, value):
+        """Return self>value."""
+
+    def __iter__(self):
+        """Implement iter(self)."""
+
+    def __le__(self, value):
+        """Return self<=value."""
+
+    def __len__(self):
+        """Return len(self)."""
+
+    def __lt__(self, value):
+        """Return self<value."""
+
+    def __ne__(self, value):
+        """Return self!=value."""
+
+    def __repr__(self):
+        """Return repr(self)."""
+
+    def collect(self) -> list:
+        """
+        Materialise the iterable as a Python list.
+
+        Returns:
+            list:
+        """
+
+class PyPropHistItemsListList(object):
+    def __eq__(self, value):
+        """Return self==value."""
+
+    def __ge__(self, value):
+        """Return self>=value."""
+
+    def __gt__(self, value):
+        """Return self>value."""
+
+    def __iter__(self):
+        """Implement iter(self)."""
+
+    def __le__(self, value):
+        """Return self<=value."""
+
+    def __len__(self):
+        """Return len(self)."""
+
+    def __lt__(self, value):
+        """Return self<value."""
+
+    def __ne__(self, value):
+        """Return self!=value."""
+
+    def __repr__(self):
+        """Return repr(self)."""
+
+    def collect(self) -> list[list]:
+        """
+        Materialise the nested iterable as a list of lists.
+
+        Returns:
+            list[list]:
+        """
+
+class PropIterable(object):
+    def __eq__(self, value):
+        """Return self==value."""
+
+    def __ge__(self, value):
+        """Return self>=value."""
+
+    def __gt__(self, value):
+        """Return self>value."""
+
+    def __iter__(self):
+        """Implement iter(self)."""
+
+    def __le__(self, value):
+        """Return self<=value."""
+
+    def __len__(self):
+        """Return len(self)."""
+
+    def __lt__(self, value):
+        """Return self<value."""
+
+    def __ne__(self, value):
+        """Return self!=value."""
+
+    def __repr__(self):
+        """Return repr(self)."""
+
+    def average(self) -> PropValue:
+        """
+        Compute the average of all property values. Alias for mean().
+
+        Returns:
+            PropValue: The average of each property values, or None if count is zero.
+        """
+
+    def collect(self) -> list:
+        """
+        Materialise the iterable as a Python list.
+
+        Returns:
+            list:
+        """
+
+    def count(self) -> int:
+        """
+        Number of properties (or rows of properties).
+
+        Returns:
+            int:
+        """
+
+    def max(self) -> PropValue:
+        """
+        Find the maximum property value and its associated time.
+
+        Returns:
+            PropValue:
+        """
+
+    def mean(self) -> PropValue:
+        """
+        Compute the mean of all property values.
+
+        Returns:
+            PropValue: The mean of each property values, or None if count is zero.
+        """
+
+    def median(self) -> PropValue:
+        """
+        Median property values.
+
+        Returns:
+            PropValue:
+        """
+
+    def min(self) -> PropValue:
+        """
+        Min property value.
+
+        Returns:
+            PropValue:
+        """
+
+    def sum(self) -> PropValue:
+        """
+        Sum of property values.
+
+        Returns:
+            PropValue:
+        """
diff --git a/python/python/raphtory/node_state/__init__.pyi b/python/python/raphtory/node_state/__init__.pyi
index 4420f2f28d..6e8c79273c 100644
--- a/python/python/raphtory/node_state/__init__.pyi
+++ b/python/python/raphtory/node_state/__init__.pyi
@@ -15,13 +15,17 @@ import raphtory.filter as filter
 from raphtory.algorithms import *
 from raphtory.vectors import *
 from raphtory.graphql import *
+from raphtory.gql import *
 from raphtory.typing import *
 import numpy as np
 from numpy.typing import NDArray
 from datetime import datetime
+import pandas
 from pandas import DataFrame
+import pyarrow  # type: ignore[import-untyped]
 from pyarrow import DataType  # type: ignore[import-untyped]
 from os import PathLike
+from decimal import Decimal
 import networkx as nx  # type: ignore
 import pyvis  # type: ignore
 from raphtory.iterables import *
@@ -75,6 +79,7 @@ __all__ = [
     "NodeStateSEIR",
     "NodeLayout",
     "NodeStateF64String",
+    "OutputNodeState",
 ]
 
 class NodeGroups(object):
@@ -2506,16 +2511,18 @@ class EarliestDateTimeView(object):
             NodeStateOptionDateTime: the computed `NodeState`
         """
 
-    def get(self, node: NodeInput, default=...) -> Optional[datetime]:
+    def get(
+        self, node: NodeInput, default: Optional[datetime] = None
+    ) -> Optional[datetime]:
         """
         Get value for node
 
         Arguments:
             node (NodeInput): the node
-           default (Optional[datetime]): the default value. Defaults to None.
+            default (Optional[datetime]): the default value. Defaults to None.
 
         Returns:
-           Optional[datetime]: the value for the node or the default value
+            Optional[datetime]: the value for the node or the default value
         """
 
     def groups(self) -> NodeGroups:
@@ -5223,11 +5230,45 @@ class UsizeIterable(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def collect(self): ...
-    def max(self): ...
-    def mean(self): ...
-    def min(self): ...
-    def sum(self): ...
+    def collect(self) -> list:
+        """
+        Materialise the iterable as a Python list.
+
+        Returns:
+            list:
+        """
+
+    def max(self) -> Any:
+        """
+        Maximum value in the iterable, or `None` if empty.
+
+        Returns:
+            Any:
+        """
+
+    def mean(self) -> float:
+        """
+        Mean of all values in the iterable.
+
+        Returns:
+            float:
+        """
+
+    def min(self) -> Any:
+        """
+        Minimum value in the iterable, or `None` if empty.
+
+        Returns:
+            Any:
+        """
+
+    def sum(self) -> Any:
+        """
+        Sum of all values in the iterable.
+
+        Returns:
+            Any:
+        """
 
 class NodeTypeView(object):
     """A lazy view over node values"""
@@ -7721,3 +7762,148 @@ class NodeStateF64String(object):
         Returns:
              Iterator[Tuple[float, str]]: Iterator over values
         """
+
+class OutputNodeState(object):
+    def __eq__(self, value):
+        """Return self==value."""
+
+    def __ge__(self, value):
+        """Return self>=value."""
+
+    def __getitem__(self, key):
+        """Return self[key]."""
+
+    def __gt__(self, value):
+        """Return self>value."""
+
+    def __iter__(self):
+        """Implement iter(self)."""
+
+    def __le__(self, value):
+        """Return self<=value."""
+
+    def __len__(self):
+        """Return len(self)."""
+
+    def __lt__(self, value):
+        """Return self<value."""
+
+    def __ne__(self, value):
+        """Return self!=value."""
+
+    def __repr__(self):
+        """Return repr(self)."""
+
+    def from_parquet(self, file_path: str, id_column: str = "id") -> OutputNodeState:
+        """
+        Get OutputNodeState from Parquet
+
+        Arguments:
+            file_path (str): filepath from which to read OutputNodeState
+            id_column (str): column to which node IDs will be written. Defaults to "id".
+
+        Returns:
+            OutputNodeState:
+        """
+
+    def get(self, node: NodeInput, default: Optional[dict] = None) -> Optional[dict]:
+        """
+        Get value for node
+
+        Arguments:
+            node (NodeInput): the node
+            default (dict, optional): the default value (dict of field name to value). Defaults to None.
+
+        Returns:
+            Optional[dict]: the value for the node or the default value
+        """
+
+    def groups(self, cols: list[str]) -> list[tuple[dict, Nodes]]:
+        """
+        Group by value
+
+        Arguments:
+            cols (list[str]): columns by which to group nodes
+
+        Returns:
+            list[tuple[dict, Nodes]]: The grouped nodes
+        """
+
+    def items(self) -> Iterator[Tuple[Node, Dict]]:
+        """
+        Iterate over items
+
+        Returns:
+            Iterator[Tuple[Node, Dict]]: Iterator over items
+        """
+
+    def merge(
+        self,
+        other: OutputNodeState,
+        index_merge_priority: str = "left",
+        default_column_merge_priority: str = "left",
+        column_merge_priority_map: Optional[dict] = None,
+    ) -> OutputNodeState:
+        """
+        Merge with another OutputNodeState (produces new OutputNodeState)
+
+        Arguments:
+            other (OutputNodeState): OutputNodeState to merge with
+            index_merge_priority (str): "left" or "right" to take left or right index, "union" to union index sets. Defaults to "left".
+            default_column_merge_priority (str): "left" or "right" to prioritize left or right columns by default, "exclude" to exclude columns by default. Defaults to "left".
+            column_merge_priority_map (dict, optional): map of column names (str) to merge priority ("left", "right", or "exclude"). Defaults to None.
+
+        Returns:
+            OutputNodeState:
+        """
+
+    def nodes(self) -> Nodes:
+        """
+        Iterate over nodes
+
+        Returns:
+            Nodes: The nodes
+        """
+
+    def sort_by(self, sort_params: Dict) -> OutputNodeState:
+        """
+        Get value for node
+
+        Arguments:
+            sort_params (Dict): Map of sort keys to sort option ('asc' or 'desc'). None defaults to 'asc'
+
+        Returns:
+            OutputNodeState: Sorted NodeState
+        """
+
+    def to_parquet(self, file_path: str, id_column: str = "id") -> None:
+        """
+        Convert OutputNodeState to Parquet
+
+        Arguments:
+            file_path (str): filepath to which OutputNodeState is written
+            id_column (str): column containing IDs of nodes. Defaults to "id".
+
+        Returns:
+            None:
+        """
+
+    def top_k(self, sort_params: Dict, k: int) -> OutputNodeState:
+        """
+        Get value for node
+
+        Arguments:
+            sort_params (Dict): Map of sort keys to sort option ('asc' or 'desc'). None defaults to 'asc'
+            k (int): Number of top entries to return.
+
+        Returns:
+            OutputNodeState: Sorted NodeState
+        """
+
+    def values(self) -> Iterator[Dict]:
+        """
+        Iterate over values
+
+        Returns:
+            Iterator[Dict]: Iterator over values (dict of field name to value)
+        """
diff --git a/python/python/raphtory/typing.py b/python/python/raphtory/typing.py
index 5da3eddb60..7d5ad41003 100644
--- a/python/python/raphtory/typing.py
+++ b/python/python/raphtory/typing.py
@@ -1,5 +1,5 @@
 from datetime import datetime, date
-from typing import Union, Literal, Mapping
+from typing import Union, Literal, Mapping, Any
 import raphtory
 
 PropValue = Union[
@@ -24,3 +24,5 @@
 TimeInput = Union[
     int, str, float, datetime, date, raphtory.EventTime, raphtory.OptionalEventTime
 ]
+
+Config = Mapping[str, Any]
diff --git a/python/python/raphtory/vectors/__init__.pyi b/python/python/raphtory/vectors/__init__.pyi
index 4473546c13..a849877afc 100644
--- a/python/python/raphtory/vectors/__init__.pyi
+++ b/python/python/raphtory/vectors/__init__.pyi
@@ -15,13 +15,17 @@ import raphtory.filter as filter
 from raphtory.algorithms import *
 from raphtory.node_state import *
 from raphtory.graphql import *
+from raphtory.gql import *
 from raphtory.typing import *
 import numpy as np
 from numpy.typing import NDArray
 from datetime import datetime
+import pandas
 from pandas import DataFrame
+import pyarrow  # type: ignore[import-untyped]
 from pyarrow import DataType  # type: ignore[import-untyped]
 from os import PathLike
+from decimal import Decimal
 import networkx as nx  # type: ignore
 import pyvis  # type: ignore
 from raphtory.iterables import *
@@ -33,6 +37,8 @@ __all__ = [
     "VectorSelection",
     "OpenAIEmbeddings",
     "VectorCache",
+    "EmbeddingServer",
+    "RunningEmbeddingServer",
     "embedding_server",
 ]
 
@@ -57,8 +63,13 @@ class VectorisedGraph(object):
           VectorSelection: The vector selection resulting from the search.
         """
 
-    def empty_selection(self):
-        """Return an empty selection of entities."""
+    def empty_selection(self) -> VectorSelection:
+        """
+        Return an empty selection of entities.
+
+        Returns:
+            VectorSelection:
+        """
 
     def entities_by_similarity(
         self,
@@ -96,8 +107,13 @@ class VectorisedGraph(object):
           VectorSelection: The vector selection resulting from the search.
         """
 
-    def optimize_index(self):
-        """Optmize the vector index"""
+    def optimize_index(self) -> None:
+        """
+        Optimise the vector index.
+
+        Returns:
+            None:
+        """
 
 class Document(object):
     """A document corresponding to a graph entity. Used to generate embeddings."""
@@ -136,7 +152,13 @@ class Embedding(object):
     def __repr__(self):
         """Return repr(self)."""
 
-    def to_arrow(self): ...
+    def to_arrow(self) -> pyarrow.Array:
+        """
+        Returns the embedding as a `pyarrow.Array` of floats.
+
+        Returns:
+            pyarrow.Array:
+        """
 
 class VectorSelection(object):
     def add_edges(self, edges: list) -> None:
@@ -295,19 +317,89 @@ class VectorSelection(object):
         """
 
 class OpenAIEmbeddings(object):
+    """
+    OpenAI-compatible embedding configuration. Pass an instance of this to
+    `VectorCache(...)` to drive `vectorise(...)`.
+
+    Arguments:
+        model (str): The OpenAI embedding model to use. Defaults to "text-embedding-3-small".
+        api_base (str, optional): Base URL for the OpenAI-compatible API. If None, falls back to OpenAI's default endpoint. Defaults to None.
+        api_key_env (str, optional): Environment variable name to read the API key from. If None, reads from `OPENAI_API_KEY`. Defaults to None.
+        org_id (str, optional): OpenAI organization id. If None, no org id is sent. Defaults to None.
+        project_id (str, optional): OpenAI project id. If None, no project id is sent. Defaults to None.
+        dim (int, optional): Embedding dimension override. If None, the model's native dimension is used. Defaults to None.
+    """
+
     def __new__(
         cls,
-        model="text-embedding-3-small",
-        api_base=None,
-        api_key_env=None,
-        org_id=None,
-        project_id=None,
-        dim=None,
+        model: str = "text-embedding-3-small",
+        api_base: Optional[str] = None,
+        api_key_env: Optional[str] = None,
+        org_id: Optional[str] = None,
+        project_id: Optional[str] = None,
+        dim: Optional[int] = None,
     ) -> OpenAIEmbeddings:
         """Create and return a new object.  See help(type) for accurate signature."""
 
 class VectorCache(object):
-    def __new__(cls, v_cache, cache=None) -> VectorCache:
+    """
+    Cache wrapping an embedding model. Pass to `Graph.vectorise(model=...)`
+    or other vectorisation entry points.
+
+    Arguments:
+        v_cache (OpenAIEmbeddings): Embedding model configuration.
+        cache (str, optional): Path to persist the embedding cache on disk. Defaults to None.
+    """
+
+    def __new__(
+        cls, v_cache: OpenAIEmbeddings, cache: Optional[str] = None
+    ) -> VectorCache:
         """Create and return a new object.  See help(type) for accurate signature."""
 
-def embedding_server(function): ...
+class EmbeddingServer(object):
+    def run(self, port: int, host: Optional[str] = None) -> None:
+        """
+        Run the embedding server in the foreground until it's stopped.
+
+        Arguments:
+            port (int): Port to listen on.
+            host (str, optional): Host interface to bind to. Defaults to None.
+
+        Returns:
+            None:
+        """
+
+    def start(self, port: int, host: Optional[str] = None) -> RunningEmbeddingServer:
+        """
+        Start the embedding server in the background and return a handle.
+
+        Arguments:
+            port (int): Port to listen on.
+            host (str, optional): Host interface to bind to. Defaults to None.
+
+        Returns:
+            RunningEmbeddingServer: handle to stop the server.
+        """
+
+class RunningEmbeddingServer(object):
+    def __enter__(self): ...
+    def __exit__(self, _exc_type, _exc_val, _exc_tb): ...
+    def stop(self) -> None:
+        """
+        Stop the running embedding server.
+
+        Returns:
+            None:
+        """
+
+def embedding_server(function: Callable[[str], list[float]]) -> EmbeddingServer:
+    """
+    Wrap a Python callable so it can be served as an OpenAI-compatible
+    embedding endpoint via `EmbeddingServer.serve(...)`.
+
+    Arguments:
+        function (Callable[[str], list[float]]): A callable that maps a text input to its embedding vector.
+
+    Returns:
+        EmbeddingServer:
+    """
diff --git a/python/scripts/gen-stubs.py b/python/scripts/gen-stubs.py
index 870648aec6..7b91a78b6f 100755
--- a/python/scripts/gen-stubs.py
+++ b/python/scripts/gen-stubs.py
@@ -10,13 +10,17 @@
     "from raphtory.vectors import *",
     "from raphtory.node_state import *",
     "from raphtory.graphql import *",
+    "from raphtory.gql import *",
     "from raphtory.typing import *",
     "import numpy as np",
     "from numpy.typing import NDArray",
     "from datetime import datetime",
+    "import pandas",
     "from pandas import DataFrame",
+    "import pyarrow  # type: ignore[import-untyped]",
     "from pyarrow import DataType  # type: ignore[import-untyped]",
     "from os import PathLike",
+    "from decimal import Decimal",
     "import networkx as nx  # type: ignore",
     "import pyvis  # type: ignore",
     "from raphtory.iterables import *",
diff --git a/python/src/lib.rs b/python/src/lib.rs
index 7e77ec8709..b1ca6c95d9 100644
--- a/python/src/lib.rs
+++ b/python/src/lib.rs
@@ -1,3 +1,4 @@
+use clam_core::python::py_gql::base_gql_module;
 use pyo3::prelude::*;
 use raphtory::python::{
     filter::base_filter_module,
@@ -12,7 +13,8 @@ use raphtory_graphql::python::pymodule::base_graphql_module;
 /// Raphtory graph analytics library
 #[pymodule]
 fn _raphtory(py: Python<'_>, m: &Bound<PyModule>) -> PyResult<()> {
-    let _ = add_raphtory_classes(m);
+    auth::init();
+    add_raphtory_classes(m)?;
 
     let graphql_module = base_graphql_module(py)?;
     let algorithm_module = base_algorithm_module(py)?;
@@ -30,5 +32,9 @@ fn _raphtory(py: Python<'_>, m: &Bound<PyModule>) -> PyResult<()> {
     m.add_submodule(&node_state_module)?;
     m.add_submodule(&filter_module)?;
     m.add_submodule(&iterables)?;
+
+    let gql_module = base_gql_module(py)?;
+    m.add_submodule(&gql_module)?;
+
     Ok(())
 }
diff --git a/python/test_utils/utils.py b/python/test_utils/utils.py
index 11aebae6f9..60d659bfcc 100644
--- a/python/test_utils/utils.py
+++ b/python/test_utils/utils.py
@@ -1,17 +1,16 @@
 import json
+import os
 import re
 import tempfile
 import time
 from datetime import datetime
-from typing import TypeVar, Callable
-import os
-import pytest
 from functools import wraps
+from typing import Callable, TypeVar
 
+import pytest
 from dateutil import parser
-
-from raphtory.graphql import GraphServer
 from raphtory import Graph, PersistentGraph
+from raphtory.graphql import GraphServer
 
 B = TypeVar("B")
 
@@ -27,6 +26,34 @@ def sort_dict_recursive(d) -> dict:
         return d
 
 
+def gql_sort_key(v):
+    if isinstance(v, dict):
+        direct = v.get("name", v.get("id", ""))
+        if direct:
+            return direct
+        # sort by src/dst for edges
+        src = gql_sort_key(v.get("src"))
+        dst = gql_sort_key(v.get("dst"))
+        if src:
+            if dst:
+                return [src, dst]
+            else:
+                return src
+        else:
+            return dst
+    else:
+        return ""
+
+
+def sort_by_gql_name_or_id(d):
+    if isinstance(d, dict):
+        return {key: sort_by_gql_name_or_id(value) for key, value in d.items()}
+    elif isinstance(d, list):
+        return sorted((sort_by_gql_name_or_id(v) for v in d), key=gql_sort_key)
+    else:
+        return d
+
+
 if "DISK_TEST_MARK" in os.environ:
 
     def with_disk_graph(func):
@@ -123,7 +150,7 @@ def measure(name: str, f: Callable[..., B], *args, print_result: bool = True) ->
     return result
 
 
-def run_graphql_test(query, expected_output, graph):
+def run_graphql_test(query, expected_output, graph, sort_output=False):
     tmp_work_dir = tempfile.mkdtemp()
     with GraphServer(tmp_work_dir, create_index=True).start(PORT) as server:
         client = server.get_client()
@@ -132,12 +159,15 @@ def run_graphql_test(query, expected_output, graph):
 
         # Convert response to a dictionary if needed and compare
         response_dict = json.loads(response) if isinstance(response, str) else response
+        if sort_output:
+            response_dict = sort_by_gql_name_or_id(response_dict)
+            expected_output = sort_by_gql_name_or_id(expected_output)
         assert (
             response_dict == expected_output
         ), f"left={sort_dict_recursive(response_dict)}\nright={sort_dict_recursive(expected_output)}"
 
 
-def run_group_graphql_test(queries_and_expected_outputs, graph):
+def run_group_graphql_test(queries_and_expected_outputs, graph, sort_output=False):
     tmp_work_dir = tempfile.mkdtemp()
     with GraphServer(tmp_work_dir, create_index=True).start(PORT) as server:
         client = server.get_client()
@@ -148,8 +178,11 @@ def run_group_graphql_test(queries_and_expected_outputs, graph):
             response_dict = (
                 json.loads(response) if isinstance(response, str) else response
             )
-            assert sort_dict_recursive(response_dict) == sort_dict_recursive(
-                expected_output
+            if sort_output:
+                response_dict = sort_by_gql_name_or_id(response_dict)
+                expected_output = sort_by_gql_name_or_id(expected_output)
+            assert (
+                response_dict == expected_output
             ), f"Expected:\n{sort_dict_recursive(expected_output)}\nGot:\n{sort_dict_recursive(response_dict)}"
 
 
@@ -232,27 +265,40 @@ def assert_set_eq(left, right):
 
 def assert_has_properties(entity, props):
     for k, v in props.items():
-        if isinstance(v, datetime):
-            actual = parser.parse(entity.properties.get(k))
-            assert v == actual
-        else:
-            assert entity.properties.get(k) == v
+        actual = entity.properties.get(k)
+        # Convert PyArrow arrays and other array-like objects to lists for comparison
+        if hasattr(actual, "to_pylist"):
+            actual = actual.to_pylist()
+        elif hasattr(actual, "tolist"):
+            actual = actual.tolist()
+        assert actual == v
 
 
 def assert_has_metadata(entity, props):
     for k, v in props.items():
-        if isinstance(v, datetime):
-            actual = parser.parse(entity.metadata.get(k))
-            assert v == actual
-        else:
-            assert entity.metadata.get(k) == v
+        actual = entity.metadata.get(k)
+        # Convert PyArrow arrays and other array-like objects to lists for comparison
+        if hasattr(actual, "to_pylist"):
+            actual = actual.to_pylist()
+        elif hasattr(actual, "tolist"):
+            actual = actual.tolist()
+        assert actual == v, f"Expected metadata {k!r} to be {v!r}, but got {actual!r}"
 
 
 def expect_unify_error(fn):
-    with pytest.raises(BaseException, match="Cannot unify"):
+    with pytest.raises(BaseException) as e:
+        # check the message
         fn()
+    print(e.value)
+    assert "Failed to unify props" in str(e.value)
 
 
 def assert_in_all(haystack: str, needles):
     for n in needles:
         assert n in haystack, f"expected to find {n!r} in {haystack!r}"
+
+
+# Needed because datetimes generated using .now() have sub millisecond precision which raphtory does not support.
+# Equality checks are failing because of this (in assert_has_properties and assert_has_metadata).
+def truncate_dt_to_ms(dt: datetime) -> datetime:
+    return dt.replace(microsecond=(dt.microsecond // 1000) * 1000)
diff --git a/python/tests/test_auth.py b/python/tests/test_auth.py
index a9c733c0b8..9c6fe3d52a 100644
--- a/python/tests/test_auth.py
+++ b/python/tests/test_auth.py
@@ -19,16 +19,48 @@
 
 RAPHTORY = "http://localhost:1736"
 
-READ_JWT = jwt.encode({"a": "ro"}, PRIVATE_KEY, algorithm="EdDSA")
+READ_JWT = jwt.encode({"access": "ro"}, PRIVATE_KEY, algorithm="EdDSA")
 READ_HEADERS = {
     "Authorization": f"Bearer {READ_JWT}",
 }
 
-WRITE_JWT = jwt.encode({"a": "rw"}, PRIVATE_KEY, algorithm="EdDSA")
+WRITE_JWT = jwt.encode({"access": "rw"}, PRIVATE_KEY, algorithm="EdDSA")
 WRITE_HEADERS = {
     "Authorization": f"Bearer {WRITE_JWT}",
 }
 
+# openssl genpkey -algorithm RSA -pkeyopt rsa_keygen_bits:2048 -out rsa-key.pem
+# openssl pkey -in rsa-key.pem -pubout -outform DER | base64 | tr -d '\n'
+RSA_PUB_KEY = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA4sqe3DlHB/DaSm8Ab99yKj0KDc/WZGFPwXeTbPwCMKKSEc8zuSuIZc/fHXLSORn1apMnDq3aLryfPwyNTbpvhGiYVyp76XQGwSlN+EF2TsJZVAzp4/EI+bnHeHyv2Yc5q6AkFtoBPNtAz2P/18g7Yv/eZqNNSd7FOeuRFRs9y0LkswvMelQmoMOK7UKdC00AyiGksvFvljNC70VT9b0uVHggJwUYT0hdCbdaDj2fCJZBEmTqBBr97u3fIHo5T41sIEEPgE2j368mI+uk6V1saEU1BU+hkcq56TabgVqUYZTln5Rdm1MuBsNz+NQwOmVxgPNo45H2cNwTfsPDAAESlwIDAQAB"
+RSA_PRIVATE_KEY = """-----BEGIN PRIVATE KEY-----
+MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDiyp7cOUcH8NpK
+bwBv33IqPQoNz9ZkYU/Bd5Ns/AIwopIRzzO5K4hlz98dctI5GfVqkycOrdouvJ8/
+DI1Num+EaJhXKnvpdAbBKU34QXZOwllUDOnj8Qj5ucd4fK/ZhzmroCQW2gE820DP
+Y//XyDti/95mo01J3sU565EVGz3LQuSzC8x6VCagw4rtQp0LTQDKIaSy8W+WM0Lv
+RVP1vS5UeCAnBRhPSF0Jt1oOPZ8IlkESZOoEGv3u7d8gejlPjWwgQQ+ATaPfryYj
+66TpXWxoRTUFT6GRyrnpNpuBWpRhlOWflF2bUy4Gw3P41DA6ZXGA82jjkfZw3BN+
+w8MAARKXAgMBAAECggEAWIH78nU2B97Syja8xGw/KUXODSreACnMDvRkKCXHkwR3
+HhUvmeXn4tf3uo3rhhZf5TpNhViK7C93tIrpAHswd0u8nFP7rNW3px3ADJE7oywM
+4ZTymJ8iQhdjRd3fYPT5qEWkn/hvgDkO94EOwT8nEhFKUeMMUDZs4RhSdBrACHk0
+CrOC2S9xbgYb5OWGV6vkSqNB0k0Kv+LxU8sS46BLE7DxfpzSXDyeYaCAkk+wbwfb
+hX7lysczbSl5l5Bulcf/LHL4Oa/5t+NcBZqyN6ylRXyqQ8LEdK4+TOJfvnePX1go
+3rG4rtyaBCuW5JD1ytxUsyfh8WE4GinUbHWzxvaYQQKBgQD5PxF2CmqMY6yiaxU3
+0LFtRS9DtwIPnPX3Wdchq7ivSU1W6sHJjNfyEggi10DSOOINalRM/ZnVlDo8hJ3A
+SybESWWzLuDZNAAAWkmoir0UpnURz847tKd8hJUivhsbdQBeKwaCuepcW6Hdwzh1
+JsJjXPovrzVGQe5FSRfBy7gswQKBgQDo78p/jEVHzuxHqSn3AsOdBdMZvPavpHb2
+Bx7tRhZOOp2QiGUHZLfjI++sQQyTu1PJqmmxOOF+eD/zkqCkLLeZsmRYOQVDOQDM
+Z+u+zKYRj7KaWBeGB2Oy/WEU0pGnhyMB/T5iHmroO0Hn4gDHqkEDvwFI7SUjLNAK
+1RjTxVgdVwKBgCRHNMBspbOHcoI1eeIk4x5Xepitk4Q4QWjeT7zb5MbGsZYcF1bB
+xFC8pSiFEi9HDkgLmPeX1gNLTuquFtP9XEgnssDQ6vNSaUmj2qLIhtrxm4qbJ5Zz
+JgmutpJW/1UQw5vxQUJX0y/cOoQvvRD4MkUKLHQyWVu/jvHQwL95anZBAoGBAIrZ
+9aGWYe3uINaOth8yHJzLTgz3oS0OIoOBtyPFNaKoOihfxalklmDlmQbbN74QWl/K
+H3qu52vWDnkJHI0Awujxd/NG+iYaIqm2AMcZgpzRRavPeyY/3WRiua4J3x035txW
+swsWCrAoMp8hD0n16Q9smj14bzzKh7ENWeFSr7W9AoGBAMOSyRdVQxVHXagh3fAa
++FNbR8pFmQC6bQGCO74DzGe6uKYpgu+XD1yinufwwsXxjieDXCHkKTGR92Kzp5VY
+Hp6HhhhCcXICRRnbxhvdpyaDbCQrT522bqRJ4rNmSVYOQQiD2vng/HVB2oWMVwa+
+fEtYNjbxjhX9qInHjHxeaNOp
+-----END PRIVATE KEY-----"""
+
 NEW_TEST_GRAPH = """mutation { newGraph(path:"test", graphType:EVENT) }"""
 
 QUERY_NAMESPACES = """query { namespaces { list{ path} } }"""
@@ -54,7 +86,7 @@ def test_expired_token():
     work_dir = tempfile.mkdtemp()
     with GraphServer(work_dir, auth_public_key=PUB_KEY).start():
         exp = time() - 100
-        token = jwt.encode({"a": "ro", "exp": exp}, PRIVATE_KEY, algorithm="EdDSA")
+        token = jwt.encode({"access": "ro", "exp": exp}, PRIVATE_KEY, algorithm="EdDSA")
         headers = {
             "Authorization": f"Bearer {token}",
         }
@@ -63,7 +95,7 @@ def test_expired_token():
         )
         assert response.status_code == 401
 
-        token = jwt.encode({"a": "rw", "exp": exp}, PRIVATE_KEY, algorithm="EdDSA")
+        token = jwt.encode({"access": "rw", "exp": exp}, PRIVATE_KEY, algorithm="EdDSA")
         headers = {
             "Authorization": f"Bearer {token}",
         }
@@ -94,7 +126,7 @@ def test_default_read_access(query):
 def test_disabled_read_access(query):
     work_dir = tempfile.mkdtemp()
     with GraphServer(
-        work_dir, auth_public_key=PUB_KEY, auth_enabled_for_reads=False
+        work_dir, auth_public_key=PUB_KEY, require_auth_for_reads=False
     ).start():
         add_test_graph()
         data = json.dumps({"query": query})
@@ -206,6 +238,70 @@ def test_raphtory_client():
         assert g.node("test") is not None
 
 
+def test_raphtory_client_write_denied_for_read_jwt():
+    """RaphtoryClient initialized with a read JWT is denied write operations."""
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir, auth_public_key=PUB_KEY).start():
+        client = RaphtoryClient(url=RAPHTORY, token=READ_JWT)
+        with pytest.raises(Exception, match="requires write access"):
+            client.new_graph("test", "EVENT")
+
+
+# --- RSA JWT support ---
+
+
+def test_rsa_signed_jwt_rs256_accepted():
+    """Server configured with an RSA public key accepts RS256-signed JWTs."""
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir, auth_public_key=RSA_PUB_KEY).start():
+        token = jwt.encode({"access": "ro"}, RSA_PRIVATE_KEY, algorithm="RS256")
+        response = requests.post(
+            RAPHTORY,
+            headers={"Authorization": f"Bearer {token}"},
+            data=json.dumps({"query": QUERY_ROOT}),
+        )
+        assert_successful_response(response)
+
+
+def test_rsa_signed_jwt_rs512_accepted():
+    """RS512 JWT is also accepted for the same RSA key (different hash, same key material)."""
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir, auth_public_key=RSA_PUB_KEY).start():
+        token = jwt.encode({"access": "ro"}, RSA_PRIVATE_KEY, algorithm="RS512")
+        response = requests.post(
+            RAPHTORY,
+            headers={"Authorization": f"Bearer {token}"},
+            data=json.dumps({"query": QUERY_ROOT}),
+        )
+        assert_successful_response(response)
+
+
+def test_eddsa_jwt_rejected_against_rsa_key():
+    """EdDSA JWT is rejected when the server is configured with an RSA public key."""
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir, auth_public_key=RSA_PUB_KEY).start():
+        token = jwt.encode({"access": "ro"}, PRIVATE_KEY, algorithm="EdDSA")
+        response = requests.post(
+            RAPHTORY,
+            headers={"Authorization": f"Bearer {token}"},
+            data=json.dumps({"query": QUERY_ROOT}),
+        )
+        assert response.status_code == 401
+
+
+def test_raphtory_client_read_jwt_can_receive_graph():
+    """RaphtoryClient initialized with a read JWT can download graphs."""
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir, auth_public_key=PUB_KEY).start():
+        client = RaphtoryClient(url=RAPHTORY, token=WRITE_JWT)
+        client.new_graph("test", "EVENT")
+        client.remote_graph("test").add_node(0, "mynode")
+
+        client2 = RaphtoryClient(url=RAPHTORY, token=READ_JWT)
+        g = client2.receive_graph("test")
+        assert g.node("mynode") is not None
+
+
 def test_upload_graph():
     work_dir = tempfile.mkdtemp()
     with GraphServer(work_dir, auth_public_key=PUB_KEY).start():
diff --git a/python/tests/test_base_install/test_filters/test_edge_property_filter.py b/python/tests/test_base_install/test_filters/test_edge_property_filter.py
index 87b650c9ee..77333e51c7 100644
--- a/python/tests/test_base_install/test_filters/test_edge_property_filter.py
+++ b/python/tests/test_base_install/test_filters/test_edge_property_filter.py
@@ -1236,42 +1236,54 @@ def check(graph):
 def test_nested_edges_getitem_property_filter_expr():
     def check(graph):
         filter_expr = filter.Edge.property("p2") > 5
-        result_ids = graph.nodes.edges[filter_expr].id.collect()
-        expected_ids = [
-            [("2", "1"), ("3", "1")],
-            [("2", "1")],
-            [("3", "1"), ("3", "4")],
-            [("3", "4")],
-            [("David Gilmour", "John Mayer")],
-            [("David Gilmour", "John Mayer"), ("John Mayer", "Jimmy Page")],
-            [("John Mayer", "Jimmy Page")],
-        ]
+        result_ids = dict(
+            zip(graph.nodes.id, (sorted(v) for v in graph.nodes.edges[filter_expr].id))
+        )
+        expected_ids = {
+            "1": [("2", "1"), ("3", "1")],
+            "2": [("2", "1")],
+            "3": [("3", "1"), ("3", "4")],
+            "4": [("3", "4")],
+            "David Gilmour": [("David Gilmour", "John Mayer")],
+            "John Mayer": [
+                ("David Gilmour", "John Mayer"),
+                ("John Mayer", "Jimmy Page"),
+            ],
+            "Jimmy Page": [("John Mayer", "Jimmy Page")],
+        }
         assert result_ids == expected_ids
 
         filter_expr2 = filter.Edge.property("p20") == "Gold_ship"
-        result_ids = graph.nodes.edges[filter_expr][filter_expr2].id.collect()
-        expected_ids = [
-            [],
-            [],
-            [],
-            [],
-            [],
-            [("John Mayer", "Jimmy Page")],
-            [("John Mayer", "Jimmy Page")],
-        ]
+        result_ids = dict(
+            zip(
+                graph.nodes.id,
+                (sorted(v) for v in graph.nodes.edges[filter_expr][filter_expr2].id),
+            )
+        )
+        expected_ids = {
+            "1": [],
+            "2": [],
+            "3": [],
+            "4": [],
+            "David Gilmour": [],
+            "John Mayer": [("John Mayer", "Jimmy Page")],
+            "Jimmy Page": [("John Mayer", "Jimmy Page")],
+        }
         assert result_ids == expected_ids
 
         filter_expr3 = filter_expr & filter_expr2
-        result_ids = graph.nodes.edges[filter_expr3].id.collect()
-        expected_ids = [
-            [],
-            [],
-            [],
-            [],
-            [],
-            [("John Mayer", "Jimmy Page")],
-            [("John Mayer", "Jimmy Page")],
-        ]
+        result_ids = dict(
+            zip(graph.nodes.id, (sorted(v) for v in graph.nodes.edges[filter_expr3].id))
+        )
+        expected_ids = {
+            "1": [],
+            "2": [],
+            "3": [],
+            "4": [],
+            "David Gilmour": [],
+            "John Mayer": [("John Mayer", "Jimmy Page")],
+            "Jimmy Page": [("John Mayer", "Jimmy Page")],
+        }
         assert result_ids == expected_ids
 
     return check
@@ -1284,26 +1296,81 @@ def check(graph):
         filter_expr2 = filter.ExplodedEdge.property("p2") == 4
 
         # Test 1
-        result_ids = graph.nodes.edges[filter_expr].explode()[filter_expr2].id.collect()
-        expected_ids = [[("1", "2")], [("1", "2")], [], [], [], [], []]
+        result_ids = dict(
+            zip(
+                graph.nodes.id,
+                (
+                    sorted(v)
+                    for v in graph.nodes.edges[filter_expr].explode()[filter_expr2].id
+                ),
+            )
+        )
+        expected_ids = {
+            "1": [("1", "2")],
+            "2": [("1", "2")],
+            "3": [],
+            "4": [],
+            "David Gilmour": [],
+            "John Mayer": [],
+            "Jimmy Page": [],
+        }
         assert result_ids == expected_ids
 
-        result_ids = graph.nodes.edges[filter_expr].explode()[filter_expr2].id.collect()
-        expected_ids = [[("1", "2")], [("1", "2")], [], [], [], [], []]
+        result_ids = dict(
+            zip(
+                graph.nodes.id,
+                (
+                    sorted(v)
+                    for v in graph.nodes.edges[filter_expr].explode()[filter_expr2].id
+                ),
+            )
+        )
+        expected_ids = {
+            "1": [("1", "2")],
+            "2": [("1", "2")],
+            "3": [],
+            "4": [],
+            "David Gilmour": [],
+            "John Mayer": [],
+            "Jimmy Page": [],
+        }
         assert result_ids == expected_ids
 
         # Test 2
         filter_expr = filter.ExplodedEdge.property("p20") == "Gold_ship"
         filter_expr2 = filter.ExplodedEdge.property("p2") == 4
-        result_ids = graph.nodes.edges.explode()[filter_expr][filter_expr2].id.collect()
-        expected_ids = [[("1", "2")], [("1", "2")], [], [], [], [], []]
+        result_ids = dict(
+            zip(
+                graph.nodes.id,
+                graph.nodes.edges.explode()[filter_expr][filter_expr2].id.collect(),
+            )
+        )
+        expected_ids = {
+            "1": [("1", "2")],
+            "2": [("1", "2")],
+            "3": [],
+            "4": [],
+            "David Gilmour": [],
+            "John Mayer": [],
+            "Jimmy Page": [],
+        }
         assert result_ids == expected_ids
 
         filter_expr = filter.ExplodedEdge.property("p20") == "Gold_ship"
         filter_expr2 = filter.ExplodedEdge.property("p2") == 4
         filter_expr3 = filter_expr & filter_expr2
-        result_ids = graph.nodes.edges.explode()[filter_expr3].id.collect()
-        expected_ids = [[("1", "2")], [("1", "2")], [], [], [], [], []]
+        result_ids = dict(
+            zip(graph.nodes.id, graph.nodes.edges.explode()[filter_expr3].id.collect())
+        )
+        expected_ids = {
+            "1": [("1", "2")],
+            "2": [("1", "2")],
+            "3": [],
+            "4": [],
+            "David Gilmour": [],
+            "John Mayer": [],
+            "Jimmy Page": [],
+        }
         assert result_ids == expected_ids
 
     return check
@@ -1313,44 +1380,63 @@ def check(graph):
 def test_nodes_nested_edges_getitem_property_filter_expr():
     def check(graph):
         filter_expr = filter.Edge.property("p2") > 5
-        result_ids = graph.nodes.neighbours.edges[filter_expr].id.collect()
-        expected_ids = [
-            [("2", "1"), ("3", "1"), ("3", "4")],
-            [("2", "1"), ("3", "1"), ("3", "1"), ("3", "4")],
-            [("2", "1"), ("3", "1"), ("2", "1"), ("3", "4")],
-            [("3", "1"), ("3", "4")],
-            [("David Gilmour", "John Mayer"), ("John Mayer", "Jimmy Page")],
-            [("David Gilmour", "John Mayer"), ("John Mayer", "Jimmy Page")],
-            [("David Gilmour", "John Mayer"), ("John Mayer", "Jimmy Page")],
-        ]
+        result_ids = dict(
+            zip(
+                graph.nodes.id,
+                (sorted(v) for v in graph.nodes.neighbours.edges[filter_expr].id),
+            )
+        )
+        expected_ids = {
+            "1": [("2", "1"), ("3", "1"), ("3", "4")],
+            "2": [("2", "1"), ("3", "1"), ("3", "1"), ("3", "4")],
+            "3": [("2", "1"), ("2", "1"), ("3", "1"), ("3", "4")],
+            "4": [("3", "1"), ("3", "4")],
+            "David Gilmour": [
+                ("David Gilmour", "John Mayer"),
+                ("John Mayer", "Jimmy Page"),
+            ],
+            "John Mayer": [
+                ("David Gilmour", "John Mayer"),
+                ("John Mayer", "Jimmy Page"),
+            ],
+            "Jimmy Page": [
+                ("David Gilmour", "John Mayer"),
+                ("John Mayer", "Jimmy Page"),
+            ],
+        }
         assert result_ids == expected_ids
 
         filter_expr2 = filter.Edge.property("p20") == "Gold_ship"
-        result_ids = graph.nodes.neighbours.edges[filter_expr][
-            filter_expr2
-        ].id.collect()
-        expected_ids = [
-            [],
-            [],
-            [],
-            [],
-            [("John Mayer", "Jimmy Page")],
-            [("John Mayer", "Jimmy Page")],
-            [("John Mayer", "Jimmy Page")],
-        ]
+        result_ids = dict(
+            zip(
+                graph.nodes.id,
+                graph.nodes.neighbours.edges[filter_expr][filter_expr2].id.collect(),
+            )
+        )
+        expected_ids = {
+            "1": [],
+            "2": [],
+            "3": [],
+            "4": [],
+            "David Gilmour": [("John Mayer", "Jimmy Page")],
+            "John Mayer": [("John Mayer", "Jimmy Page")],
+            "Jimmy Page": [("John Mayer", "Jimmy Page")],
+        }
         assert result_ids == expected_ids
 
         filter_expr3 = filter_expr & filter_expr2
-        result_ids = graph.nodes.neighbours.edges[filter_expr3].id.collect()
-        expected_ids = [
-            [],
-            [],
-            [],
-            [],
-            [("John Mayer", "Jimmy Page")],
-            [("John Mayer", "Jimmy Page")],
-            [("John Mayer", "Jimmy Page")],
-        ]
+        result_ids = dict(
+            zip(graph.nodes.id, graph.nodes.neighbours.edges[filter_expr3].id.collect())
+        )
+        expected_ids = {
+            "1": [],
+            "2": [],
+            "3": [],
+            "4": [],
+            "David Gilmour": [("John Mayer", "Jimmy Page")],
+            "John Mayer": [("John Mayer", "Jimmy Page")],
+            "Jimmy Page": [("John Mayer", "Jimmy Page")],
+        }
         assert result_ids == expected_ids
 
     return check
diff --git a/python/tests/test_base_install/test_filters/test_exploded_edge_filter.py b/python/tests/test_base_install/test_filters/test_exploded_edge_filter.py
index 977196b47b..03860e8c3a 100644
--- a/python/tests/test_base_install/test_filters/test_exploded_edge_filter.py
+++ b/python/tests/test_base_install/test_filters/test_exploded_edge_filter.py
@@ -824,7 +824,7 @@ def test_all_property_types(GraphClass):
 
     with pytest.raises(Exception) as e:
         filter.ExplodedEdge.property("name").fuzzy_search(2, 2, False)
-    assert "'int' object cannot be converted to 'PyString'" in str(e.value)
+    assert "argument 'prop_value': 'int' object cannot be cast as 'str'" in str(e.value)
 
     missing_prop = [
         (filter.ExplodedEdge.property("blah") == 2),
diff --git a/python/tests/test_base_install/test_filters/test_node_filter.py b/python/tests/test_base_install/test_filters/test_node_filter.py
index 464ca867bf..e95c238493 100644
--- a/python/tests/test_base_install/test_filters/test_node_filter.py
+++ b/python/tests/test_base_install/test_filters/test_node_filter.py
@@ -436,21 +436,14 @@ def test_filter_nodes_by_column():
     graph.add_node(1, 4, {})
     graph.add_node(1, 5, {})
 
+    expected = {i: {"bool_col": v % 2 != 0} for (v, i) in enumerate(graph.nodes.id)}
     actual = alternating_mask(graph)
-    expected = {
-        1: {"bool_col": False},
-        2: {"bool_col": True},
-        3: {"bool_col": False},
-        4: {"bool_col": True},
-        5: {"bool_col": False},
-    }
     assert actual == expected
 
     filter_expr = filter.Node.by_state_column(actual, "bool_col")
     result_ids = sorted(graph.filter(filter_expr).nodes.id)
-    expected_ids = sorted([2, 4])
+    expected_ids = sorted(i for i, v in expected.items() if v["bool_col"])
     assert result_ids == expected_ids
 
     result_ids = sorted(graph.nodes[filter_expr].id)
-    expected_ids = sorted([2, 4])
     assert result_ids == expected_ids
diff --git a/python/tests/test_base_install/test_filters/test_node_property_filter.py b/python/tests/test_base_install/test_filters/test_node_property_filter.py
index ef41cdcf46..41824dbd5c 100644
--- a/python/tests/test_base_install/test_filters/test_node_property_filter.py
+++ b/python/tests/test_base_install/test_filters/test_node_property_filter.py
@@ -867,26 +867,39 @@ def check(graph):
         assert result_ids == expected_ids
 
         filter_expr = filter.Node.property("p100") > 30
-        result_ids = sorted(graph.nodes[filter_expr].neighbours.name.collect())
-        expected_ids = [["1", "2", "4"], ["2", "3"]]
+        result_ids = dict(
+            zip(
+                graph.nodes[filter_expr].id,
+                (sorted(v) for v in graph.nodes[filter_expr].neighbours.name),
+            )
+        )
+        expected_ids = {"1": ["2", "3"], "3": ["1", "2", "4"]}
         assert result_ids == expected_ids
 
         filter_expr = filter.Node.property("p100") > 30
-        result_ids = sorted(graph.filter(filter_expr).nodes.neighbours.name.collect())
-        expected_ids = [
-            ["1"],
-            ["3"],
-        ]  # graph filter applies to nodes neighbours as well
+        result_ids = dict(
+            zip(
+                graph.filter(filter_expr).nodes.id,
+                graph.filter(filter_expr).nodes.neighbours.name.collect(),
+            )
+        )
+        expected_ids = {
+            "3": ["1"],
+            "1": ["3"],
+        }  # graph filter applies to nodes neighbours as well
         assert result_ids == expected_ids
 
         filter_expr = filter.Node.property("p100") > 30
-        result_ids = sorted(graph.nodes[filter_expr].degree())
-        expected_ids = [2, 3]
+        result_ids = graph.nodes[filter_expr].degree()
+        expected_ids = {"1": 2, "3": 3}
         assert result_ids == expected_ids
 
         filter_expr = filter.Node.property("p100") > 30
-        result_ids = sorted(graph.filter(filter_expr).nodes.degree())
-        expected_ids = [1, 1]  # graph filter applies to nodes neighbours as well
+        result_ids = graph.filter(filter_expr).nodes.degree()
+        expected_ids = {
+            "1": 1,
+            "3": 1,
+        }  # graph filter applies to nodes neighbours as well
         assert result_ids == expected_ids
 
         # Test 2
@@ -910,47 +923,84 @@ def check(graph):
         filter_expr = filter.Node.property("p100") > 30
 
         # Test 1
-        result_ids = graph.nodes.id.collect()
-        expected_ids = ["1", "2", "3", "4", "David Gilmour", "John Mayer", "Jimmy Page"]
-        assert result_ids == expected_ids
-
-        result_ids = graph.nodes.neighbours.id.collect()
-        expected_ids = [
-            ["2", "3"],
-            ["1", "3"],
-            ["1", "2", "4"],
-            ["3"],
-            ["John Mayer"],
-            ["David Gilmour", "Jimmy Page"],
-            ["John Mayer"],
-        ]
-        assert result_ids == expected_ids
-
-        result_ids = graph.nodes.neighbours[filter_expr].id.collect()
-        expected_ids = [["3"], ["1", "3"], ["1"], ["3"], [], [], []]
-        assert result_ids == expected_ids
-
-        result_ids = graph.nodes.neighbours[filter_expr].neighbours.id.collect()
-        expected_ids = [
-            ["1", "2", "4"],
-            ["2", "3", "1", "2", "4"],
-            ["2", "3"],
-            ["1", "2", "4"],
-            [],
-            [],
-            [],
-        ]
+        node_ids = graph.nodes.id.collect()
+        expected_ids = ["1", "2", "3", "4", "David Gilmour", "Jimmy Page", "John Mayer"]
+        assert sorted(node_ids) == expected_ids
+
+        result_ids = dict(zip(node_ids, (sorted(v) for v in graph.nodes.neighbours.id)))
+        expected_ids = {
+            "1": ["2", "3"],
+            "2": ["1", "3"],
+            "3": ["1", "2", "4"],
+            "4": ["3"],
+            "David Gilmour": ["John Mayer"],
+            "John Mayer": ["David Gilmour", "Jimmy Page"],
+            "Jimmy Page": ["John Mayer"],
+        }
+        assert result_ids == expected_ids
+
+        result_ids = dict(
+            zip(node_ids, (sorted(v) for v in graph.nodes.neighbours[filter_expr].id))
+        )
+        expected_ids = {
+            "1": ["3"],
+            "2": ["1", "3"],
+            "3": ["1"],
+            "4": ["3"],
+            "David Gilmour": [],
+            "John Mayer": [],
+            "Jimmy Page": [],
+        }
+        assert result_ids == expected_ids
+
+        result_ids = dict(
+            zip(
+                node_ids,
+                (sorted(v) for v in graph.nodes.neighbours[filter_expr].neighbours.id),
+            )
+        )
+        expected_ids = {
+            "1": ["1", "2", "4"],
+            "2": ["1", "2", "2", "3", "4"],
+            "3": ["2", "3"],
+            "4": ["1", "2", "4"],
+            "David Gilmour": [],
+            "John Mayer": [],
+            "Jimmy Page": [],
+        }
         assert result_ids == expected_ids
 
         # Test 2
         filter_expr2 = filter.Node.property("p9") == 5
-        result_ids = graph.nodes.neighbours[filter_expr][filter_expr2].id.collect()
-        expected_ids = [[], ["1"], ["1"], [], [], [], []]
+        result_ids = dict(
+            zip(
+                node_ids, graph.nodes.neighbours[filter_expr][filter_expr2].id.collect()
+            )
+        )
+        expected_ids = {
+            "1": [],
+            "2": ["1"],
+            "3": ["1"],
+            "4": [],
+            "David Gilmour": [],
+            "John Mayer": [],
+            "Jimmy Page": [],
+        }
         assert result_ids == expected_ids
 
         filter_expr3 = filter_expr & filter_expr2
-        result_ids = graph.nodes.neighbours[filter_expr3].id.collect()
-        expected_ids = [[], ["1"], ["1"], [], [], [], []]
+        result_ids = dict(
+            zip(node_ids, graph.nodes.neighbours[filter_expr3].id.collect())
+        )
+        expected_ids = {
+            "1": [],
+            "2": ["1"],
+            "3": ["1"],
+            "4": [],
+            "David Gilmour": [],
+            "John Mayer": [],
+            "Jimmy Page": [],
+        }
         assert result_ids == expected_ids
 
     return check
@@ -963,7 +1013,7 @@ def check(graph):
         assert graph.node("1") is not None
 
         # Test 1
-        result_ids = graph.node("1").neighbours.id.collect()
+        result_ids = sorted(graph.node("1").neighbours.id)
         expected_ids = ["2", "3"]
         assert result_ids == expected_ids
 
@@ -971,7 +1021,7 @@ def check(graph):
         expected_ids = ["3"]
         assert result_ids == expected_ids
 
-        result_ids = graph.node("1").neighbours[filter_expr].neighbours.id.collect()
+        result_ids = sorted(graph.node("1").neighbours[filter_expr].neighbours.id)
         expected_ids = ["1", "2", "4"]
         assert result_ids == expected_ids
 
diff --git a/python/tests/test_base_install/test_graphdb/test_algorithms.py b/python/tests/test_base_install/test_graphdb/test_algorithms.py
index e9736c713e..ac80a5d138 100644
--- a/python/tests/test_base_install/test_graphdb/test_algorithms.py
+++ b/python/tests/test_base_install/test_graphdb/test_algorithms.py
@@ -1,8 +1,8 @@
 import pytest
-
-from raphtory import Graph
-from raphtory import algorithms
-from raphtory import graph_loader
+from raphtory import Graph, algorithms, graph_loader
+from numpy.linalg import norm
+import math
+import numpy as np
 
 
 def gen_graph():
@@ -43,7 +43,6 @@ def test_local_clustering_coefficient():
     assert actual == expected
     expected = {k: {"lcc": v} for k, v in expected.items()}
     actual = algorithms.local_clustering_coefficient_batch(g, list(range(1, 9)))
-    # actual = {str(i): actual[i]["lcc"] for i in range(1, 9)}
     assert actual == expected
 
 
@@ -390,8 +389,7 @@ def test_degree_centrality():
 
 def test_max_min_degree():
     from raphtory import Graph
-    from raphtory.algorithms import max_degree
-    from raphtory.algorithms import min_degree
+    from raphtory.algorithms import max_degree, min_degree
 
     g = Graph()
     g.add_edge(0, 0, 1, {})
@@ -506,10 +504,14 @@ def test_betweenness_centrality():
 
 def test_hits_algorithm():
     g = graph_loader.lotr_graph()
-    assert algorithms.hits(g).get("Aldor") == {
+    expected = {
         "hub_score": 0.0035840950440615416,
         "auth_score": 0.007476256228983402,
     }
+    actual = algorithms.hits(g).get("Aldor")
+    assert all(
+        math.isclose(actual[key], e, rel_tol=1e-6) for key, e in expected.items()
+    )
 
 
 def test_balance_algorithm():
@@ -635,7 +637,7 @@ def test_temporal_SEIR():
 
 
 ##########
-def test_nodestate_merge_test():
+def test_nodestate_merge():
     from raphtory.algorithms import degree_centrality, pagerank
 
     g = Graph()
@@ -717,170 +719,41 @@ def test_max_weight_matching():
     assert max_weight.dst(3) is None
 
 
+@pytest.mark.skip(reason="Probability test - to be investigated")
 def test_fast_rp():
     g = Graph()
     edges = [
         (1, 2, 1),
         (1, 3, 1),
         (2, 3, 1),
+        (3, 1, 1),
+        (2, 1, 1),
         (4, 5, 1),
         (4, 6, 1),
         (4, 7, 1),
         (5, 6, 1),
         (5, 7, 1),
         (6, 7, 1),
+        (7, 5, 1),
         (6, 8, 1),
     ]
     for src, dst, ts in edges:
         g.add_edge(ts, src, dst)
 
     result = algorithms.fast_rp(g, 16, 1.0, [1.0, 1.0], 42)
-    baseline = {
-        1: [
-            1.6817928305074292,
-            0.4204482076268573,
-            -0.4204482076268573,
-            0.0,
-            0.0,
-            2.1022410381342866,
-            0.4204482076268573,
-            0.4204482076268573,
-            2.1022410381342866,
-            -0.8408964152537146,
-            0.0,
-            1.6817928305074292,
-            0.0,
-            -1.6817928305074292,
-            0.0,
-            -0.8408964152537146,
-        ],
-        2: [
-            0.4204482076268573,
-            1.6817928305074292,
-            -1.6817928305074292,
-            0.0,
-            0.0,
-            0.8408964152537146,
-            1.6817928305074292,
-            1.6817928305074292,
-            2.1022410381342866,
-            -2.1022410381342866,
-            0.0,
-            0.4204482076268573,
-            0.0,
-            -0.4204482076268573,
-            0.0,
-            -2.1022410381342866,
-        ],
-        3: [
-            0.4204482076268573,
-            0.4204482076268573,
-            -0.4204482076268573,
-            0.0,
-            0.0,
-            2.1022410381342866,
-            0.4204482076268573,
-            0.4204482076268573,
-            0.8408964152537146,
-            -2.1022410381342866,
-            0.0,
-            0.4204482076268573,
-            0.0,
-            -0.4204482076268573,
-            0.0,
-            -2.1022410381342866,
-        ],
-        4: [
-            -1.4014940254228576,
-            0.560597610169143,
-            1.121195220338286,
-            -0.2802988050845715,
-            0.2802988050845715,
-            -0.2802988050845715,
-            0.2802988050845715,
-            0.0,
-            -1.6817928305074292,
-            0.0,
-            0.0,
-            -0.2802988050845715,
-            0.2802988050845715,
-            0.2802988050845715,
-            -0.2802988050845715,
-            -1.6817928305074292,
-        ],
-        5: [
-            0.0,
-            1.9620916355920008,
-            -1.6817928305074292,
-            -1.6817928305074292,
-            0.2802988050845715,
-            -0.2802988050845715,
-            0.2802988050845715,
-            1.4014940254228576,
-            -0.2802988050845715,
-            0.0,
-            0.0,
-            -1.6817928305074292,
-            0.2802988050845715,
-            0.2802988050845715,
-            -0.2802988050845715,
-            1.121195220338286,
-        ],
-        6: [
-            -0.21022410381342865,
-            0.6306723114402859,
-            -1.6817928305074292,
-            -1.4715687266940005,
-            1.6817928305074292,
-            -1.6817928305074292,
-            0.0,
-            -1.4715687266940005,
-            -0.21022410381342865,
-            0.0,
-            0.0,
-            -0.4204482076268573,
-            1.6817928305074292,
-            0.21022410381342865,
-            -0.21022410381342865,
-            -0.21022410381342865,
-        ],
-        7: [
-            1.4014940254228576,
-            1.9620916355920008,
-            -0.2802988050845715,
-            1.121195220338286,
-            0.2802988050845715,
-            -0.2802988050845715,
-            1.6817928305074292,
-            0.0,
-            -0.2802988050845715,
-            0.0,
-            0.0,
-            -0.2802988050845715,
-            0.2802988050845715,
-            1.6817928305074292,
-            -1.6817928305074292,
-            -1.6817928305074292,
-        ],
-        8: [
-            -1.6817928305074292,
-            1.6817928305074292,
-            -0.8408964152537146,
-            0.8408964152537146,
-            0.8408964152537146,
-            -0.8408964152537146,
-            -1.6817928305074292,
-            -0.8408964152537146,
-            0.0,
-            0.0,
-            0.0,
-            -1.6817928305074292,
-            0.8408964152537146,
-            0.0,
-            0.0,
-            0.0,
-        ],
-    }
-
     result = {n.id: v["embedding_state"] for n, v in result.items()}
-    assert result == baseline
+
+    group_1 = [1, 2, 3]
+    group_2 = [4, 5, 6, 7]
+
+    d1 = max(
+        norm(np.array(result[i]) - np.array(result[j]))
+        for i in group_1
+        for j in group_1
+    )
+    d2 = min(
+        norm(np.array(result[i]) - np.array(result[j]))
+        for i in group_1
+        for j in group_2
+    )
+    assert d1 < d2
diff --git a/python/tests/test_base_install/test_graphdb/test_event_time.py b/python/tests/test_base_install/test_graphdb/test_event_time.py
index fef6a73e5e..27d2833bef 100644
--- a/python/tests/test_base_install/test_graphdb/test_event_time.py
+++ b/python/tests/test_base_install/test_graphdb/test_event_time.py
@@ -98,13 +98,13 @@ def test_time_input_parsing(example_graph):
         assert gw.nodes == [1], f"Unexpected nodes for end={end!r}"
 
     assert g.window(86400000, 88200000).nodes == [2]
-    assert g.window(86400000, 88200001).nodes == [2, 3]
+    assert g.window(86400000, 88200001).nodes.id.sorted_by_id() == [2, 3]
     gw = g.window(88200000, "2000-01-01")
     assert gw.nodes == [3]
     gw = g.window(88200000, "2000-01-01 00:00:01")
-    assert gw.nodes == [3, 4]
+    assert gw.nodes.id.sorted_by_id() == [3, 4]
     gw = g.window(88200000, "2000-01-02")
-    assert gw.nodes == [3, 4]
+    assert gw.nodes.id.sorted_by_id() == [3, 4]
 
 
 def test_optional_event_time_none_comparison():
diff --git a/python/tests/test_base_install/test_graphdb/test_graphdb.py b/python/tests/test_base_install/test_graphdb/test_graphdb.py
index 2c8811d200..525cc9db6b 100644
--- a/python/tests/test_base_install/test_graphdb/test_graphdb.py
+++ b/python/tests/test_base_install/test_graphdb/test_graphdb.py
@@ -1,28 +1,28 @@
 from __future__ import unicode_literals
-from decimal import Decimal
+
 import math
-import sys
+import os
+import pickle
 import random
 import re
-
-import pandas as pd
-import pandas.core.frame
-import pytest
-import pyarrow as pa
-from raphtory import Graph, PersistentGraph
-from raphtory import algorithms
-from raphtory import graph_loader
+import shutil
+import string
+import sys
 import tempfile
+from decimal import Decimal
 from math import isclose
 from datetime import date, datetime, timezone
 import string
 from pathlib import Path
-from pytest import fixture
-from numpy.testing import assert_equal as check_arr
-import os
-import shutil
+
 import numpy as np
-import pickle
+import pandas as pd
+import pandas.core.frame
+import pyarrow as pa
+import pytest
+from numpy.testing import assert_equal as check_arr
+from pytest import fixture
+from raphtory import Graph, PersistentGraph, algorithms, graph_loader
 from utils import with_disk_graph
 
 base_dir = Path(__file__).parent
@@ -256,29 +256,19 @@ def test_windowed_graph_edges():
     def check(g):
         view = g.window(0, sys.maxsize)
 
-        tedges = [v.edges for v in view.nodes]
-        edges = []
-        for e_iter in tedges:
-            for e in e_iter:
-                edges.append([e.src.id, e.dst.id])
-
-        assert edges == [[1, 1], [1, 2], [1, 3], [1, 2], [3, 2], [1, 3], [3, 2]]
-
-        tedges = [v.in_edges for v in view.nodes]
-        in_edges = []
-        for e_iter in tedges:
-            for e in e_iter:
-                in_edges.append([e.src.id, e.dst.id])
+        edges = {v.id: sorted(v.edges.id) for v in view.nodes}
+        assert edges == {
+            1: [(1, 1), (1, 2), (1, 3)],
+            2: [(1, 2), (3, 2)],
+            3: [(1, 3), (3, 2)],
+        }
 
-        assert in_edges == [[1, 1], [1, 2], [3, 2], [1, 3]]
+        in_edges = {v.id: sorted(v.in_edges.id) for v in view.nodes}
+        assert in_edges == {1: [(1, 1)], 2: [(1, 2), (3, 2)], 3: [(1, 3)]}
 
-        tedges = [v.out_edges for v in view.nodes]
-        out_edges = []
-        for e_iter in tedges:
-            for e in e_iter:
-                out_edges.append([e.src.id, e.dst.id])
+        out_edges = {v.id: sorted(v.out_edges.id) for v in view.nodes}
 
-        assert out_edges == [[1, 1], [1, 2], [1, 3], [3, 2]]
+        assert out_edges == {1: [(1, 1), (1, 2), (1, 3)], 2: [], 3: [(3, 2)]}
 
     check(g)
 
@@ -321,14 +311,20 @@ def check(g):
 
         view = g.window(min_size, max_size)
 
-        neighbours = view.nodes.neighbours.id.collect()
-        assert neighbours == [[1, 2, 3], [1, 3], [1, 2]]
+        neighbours = dict(
+            zip(view.nodes.id, (sorted(v) for v in view.nodes.neighbours.id))
+        )
+        assert neighbours == {1: [1, 2, 3], 2: [1, 3], 3: [1, 2]}
 
-        in_neighbours = view.nodes.in_neighbours.id.collect()
-        assert in_neighbours == [[1, 2], [1, 3], [1]]
+        in_neighbours = dict(
+            zip(view.nodes.id, (sorted(v) for v in view.nodes.in_neighbours.id))
+        )
+        assert in_neighbours == {1: [1, 2], 2: [1, 3], 3: [1]}
 
-        out_neighbours = view.nodes.out_neighbours.id.collect()
-        assert out_neighbours == [[1, 2, 3], [1], [2]]
+        out_neighbours = dict(
+            zip(view.nodes.id, (sorted(v) for v in view.nodes.out_neighbours.id))
+        )
+        assert out_neighbours == {1: [1, 2, 3], 2: [1], 3: [2]}
 
     check(g)
 
@@ -1257,7 +1253,7 @@ def test_save_missing_dir():
     g = create_graph()
     tmpdirname = tempfile.TemporaryDirectory()
     inner_folder = "".join(random.choice(string.ascii_letters) for _ in range(10))
-    graph_path = tmpdirname.name + "/" + inner_folder + "/test_graph.bin"
+    graph_path = tmpdirname.name + "/" + inner_folder + "/test_graph"
     with pytest.raises(Exception):
         g.save_to_file(graph_path)
 
@@ -1687,46 +1683,39 @@ def check(g):
 
 
 def test_edge_history():
+    expected_history = {(1, 2): [1, 3], (1, 3): [2], (1, 4): [4]}
     g = Graph()
+    for (src, dst), timestamps in expected_history.items():
+        for t in timestamps:
+            g.add_edge(t, src, dst)
 
-    g.add_edge(1, 1, 2)
-    g.add_edge(2, 1, 3)
-    g.add_edge(3, 1, 2)
-    g.add_edge(4, 1, 4)
-
-    @with_disk_graph
-    def check(g):
-        view = g.window(1, 5)
-        view2 = g.window(1, 4)
-
-        check_arr(g.edge(1, 2).history.t.collect(), [1, 3])
-        check_arr(view.edge(1, 4).history.t.collect(), [4])
-        check_arr(g.edges.history.t.collect(), [[1, 3], [2], [4]])
-        check_arr(view2.edges.history.t.collect(), [[1, 3], [2]])
+    view = g.window(1, 5)
+    view2 = g.window(1, 4)
 
-        old_way = []
-        for e in g.edges:
-            old_way.append(e.history.collect())
-        check_arr(g.edges.history.collect(), old_way)
+    check_arr(g.edge(1, 2).history.t.collect(), expected_history[(1, 2)])
+    check_arr(view.edge(1, 4).history.t.collect(), expected_history[(1, 4)])
+    check_arr(g.edges.history.t.collect(), [expected_history[e] for e in g.edges.id])
+    assert sorted(view2.edges.id) == [(1, 2), (1, 3)]
+    check_arr(
+        view2.edges.history.t.collect(), [expected_history[e] for e in view2.edges.id]
+    )
 
-        check_arr(
-            g.nodes.edges.history.t.collect(),
-            [
-                [[1, 3], [2], [4]],
-                [[1, 3]],
-                [[2]],
-                [[4]],
-            ],
-        )
+    old_way = []
+    for e in g.edges:
+        old_way.append(e.history.collect())
+    check_arr(g.edges.history.collect(), old_way)
 
-        old_way2 = []
-        for edges in g.nodes.edges:
-            for edge in edges:
-                old_way2.append(edge.history.collect())
-        new_way = g.nodes.edges.history.collect()
-        check_arr([np.array(item) for sublist in new_way for item in sublist], old_way2)
+    res = g.nodes.edges.history.t.collect()
+    for node, v in zip(g.nodes, res):
+        for e, vv in zip(node.edges.id, v):
+            check_arr(vv, expected_history[e])
 
-    check(g)
+    old_way2 = []
+    for edges in g.nodes.edges:
+        for edge in edges:
+            old_way2.append(edge.history.collect())
+    new_way = g.nodes.edges.history.collect()
+    check_arr([np.array(item) for sublist in new_way for item in sublist], old_way2)
 
 
 def test_lotr_edge_history():
@@ -2230,7 +2219,7 @@ def test_exclude_nodes():
     @with_disk_graph
     def check(g):
         exclude_nodes = g.exclude_nodes([1])
-        assert exclude_nodes.nodes.id.collect() == [2, 3]
+        assert sorted(exclude_nodes.nodes.id.collect()) == [2, 3]
 
     check(g)
 
@@ -2274,9 +2263,11 @@ def check_g_inner(mg):
             assert mg.node(4).metadata.get("abc") == "xyz"
             check_arr(mg.node(1).history.t.collect(), [-1, 0, 0, 1, 1, 2])
             check_arr(mg.node(4).history.t.collect(), [6, 8])
-            assert mg.nodes.id.collect() == [1, 2, 3, 4]
+            assert len(mg.nodes.id.collect()) == 4
+            assert set(mg.nodes.id.collect()) == {1, 3, 2, 4}
             assert set(mg.edges.id) == {(1, 1), (1, 2), (1, 3), (2, 1), (3, 2), (2, 4)}
-            assert g.nodes.id.collect() == mg.nodes.id.collect()
+            assert len(g.nodes.id.collect()) == len(mg.nodes.id.collect())
+            assert set(g.nodes.id.collect()) == set(mg.nodes.id.collect())
             assert set(g.edges.id) == set(mg.edges.id)
             assert mg.node(1).metadata == {}
             assert mg.node(4).metadata == {"abc": "xyz"}
@@ -2632,12 +2623,8 @@ def test_type_filter():
     g.add_node(1, 3, node_type="timer")
     g.add_node(1, 4, node_type="wallet")
 
-    @with_disk_graph
-    def check(g):
-        assert [node.name for node in g.nodes.type_filter(["wallet"])] == ["1", "4"]
-        assert g.subgraph_node_types(["timer"]).nodes.name.collect() == ["2", "3"]
-
-    check(g)
+    assert sorted(node.name for node in g.nodes.type_filter(["wallet"])) == ["1", "4"]
+    assert g.subgraph_node_types(["timer"]).nodes.name.sorted_by_id() == ["2", "3"]
 
     g = PersistentGraph()
     g.add_node(1, 1, node_type="wallet")
@@ -2645,23 +2632,19 @@ def check(g):
     g.add_node(3, 3, node_type="timer")
     g.add_node(4, 4, node_type="wallet")
 
-    # @with_disk_graph # FIXME PersistentGraph cannot be used with with_disk_graph
-    def check(g):
-        assert [node.name for node in g.nodes.type_filter(["wallet"])] == ["1", "4"]
-        assert g.subgraph_node_types(["timer"]).nodes.name.collect() == ["2", "3"]
-
-        subgraph = g.subgraph([1, 2, 3])
-        assert [node.name for node in subgraph.nodes.type_filter(["wallet"])] == ["1"]
-        assert subgraph.subgraph_node_types(["timer"]).nodes.name.collect() == [
-            "2",
-            "3",
-        ]
+    assert sorted(node.name for node in g.nodes.type_filter(["wallet"])) == ["1", "4"]
+    assert sorted(g.subgraph_node_types(["timer"]).nodes.name.collect()) == ["2", "3"]
 
-        w = g.window(1, 4)
-        assert [node.name for node in w.nodes.type_filter(["wallet"])] == ["1"]
-        assert w.subgraph_node_types(["timer"]).nodes.name.collect() == ["2", "3"]
+    subgraph = g.subgraph([1, 2, 3])
+    assert [node.name for node in subgraph.nodes.type_filter(["wallet"])] == ["1"]
+    assert sorted(subgraph.subgraph_node_types(["timer"]).nodes.name.collect()) == [
+        "2",
+        "3",
+    ]
 
-    check(g)
+    w = g.window(1, 4)
+    assert [node.name for node in w.nodes.type_filter(["wallet"])] == ["1"]
+    assert sorted(w.subgraph_node_types(["timer"]).nodes.name.collect()) == ["2", "3"]
 
     g = Graph()
     g.add_node(1, 1, node_type="wallet")
@@ -2672,13 +2655,12 @@ def check(g):
     g.add_edge(2, 2, 3, layer="layer1")
     g.add_edge(3, 2, 4, layer="layer2")
 
-    @with_disk_graph
-    def check(g):
-        layer = g.layers(["layer1"])
-        assert [node.name for node in layer.nodes.type_filter(["wallet"])] == ["1"]
-        assert layer.subgraph_node_types(["timer"]).nodes.name.collect() == ["2", "3"]
-
-    check(g)
+    layer = g.layers(["layer1"])
+    assert [node.name for node in layer.nodes.type_filter(["wallet"])] == ["1"]
+    assert sorted(layer.subgraph_node_types(["timer"]).nodes.name.collect()) == [
+        "2",
+        "3",
+    ]
 
     g = Graph()
     g.add_node(1, 1, node_type="a")
@@ -2698,84 +2680,117 @@ def check(g):
     g.add_edge(2, 5, 6, layer="a")
     g.add_edge(2, 3, 6, layer="a")
 
-    # @with_disk_graph # FIXME: add support for type_filters + layers support on edges
-    def check(g):
-        assert g.nodes.type_filter([""]).name.collect() == ["7", "8", "9"]
-
-        assert g.nodes.type_filter(["a"]).name.collect() == ["1", "4"]
-        assert g.nodes.type_filter(["a", "c"]).name.collect() == ["1", "4", "5"]
-        assert g.nodes.type_filter(["a"]).neighbours.name.collect() == [
-            ["2"],
-            ["2", "5"],
-        ]
+    assert sorted(g.nodes.type_filter([""]).name.collect()) == ["7", "8", "9"]
 
-        assert g.nodes.degree().collect() == [1, 3, 2, 2, 2, 2, 0, 0, 0]
-        assert g.nodes.type_filter(["a"]).degree().collect() == [1, 2]
-        assert g.nodes.type_filter(["d"]).degree().collect() == []
-        assert g.nodes.type_filter([]).name.collect() == []
+    assert sorted(g.nodes.type_filter(["a"]).name.collect()) == ["1", "4"]
+    assert sorted(g.nodes.type_filter(["a", "c"]).name.collect()) == ["1", "4", "5"]
+    assert dict(
+        zip(
+            g.nodes.type_filter(["a"]).id,
+            (sorted(v) for v in g.nodes.type_filter(["a"]).neighbours.name),
+        )
+    ) == {
+        1: ["2"],
+        4: ["2", "5"],
+    }
 
-        assert len(g.nodes) == 9
-        assert len(g.nodes.type_filter(["b"])) == 2
-        assert len(g.nodes.type_filter(["d"])) == 0
+    assert g.nodes.degree() == {1: 1, 2: 3, 3: 2, 4: 2, 5: 2, 6: 2, 7: 0, 8: 0, 9: 0}
+    assert g.nodes.type_filter(["a"]).degree() == {1: 1, 4: 2}
+    assert g.nodes.type_filter(["d"]).degree().collect() == []
+    assert g.nodes.type_filter([]).name.collect() == []
 
-        assert g.nodes.type_filter(["d"]).neighbours.name.collect() == []
-        assert g.nodes.type_filter(["a"]).neighbours.name.collect() == [
-            ["2"],
-            ["2", "5"],
-        ]
-        assert g.nodes.type_filter(["a", "c"]).neighbours.name.collect() == [
-            ["2"],
-            ["2", "5"],
-            ["4", "6"],
-        ]
+    assert len(g.nodes) == 9
+    assert len(g.nodes.type_filter(["b"])) == 2
+    assert len(g.nodes.type_filter(["d"])) == 0
 
-        assert g.nodes.type_filter(["a"]).neighbours.type_filter(
-            ["c"]
-        ).name.collect() == [
-            [],
-            ["5"],
-        ]
-        assert g.nodes.type_filter(["a"]).neighbours.type_filter([]).name.collect() == [
-            [],
-            [],
-        ]
-        assert g.nodes.type_filter(["a"]).neighbours.type_filter(
-            ["b", "c"]
-        ).name.collect() == [["2"], ["2", "5"]]
-        assert g.nodes.type_filter(["a"]).neighbours.type_filter(
-            ["d"]
-        ).name.collect() == [
-            [],
-            [],
-        ]
-        assert g.nodes.type_filter(["a"]).neighbours.neighbours.name.collect() == [
-            ["1", "3", "4"],
-            ["1", "3", "4", "4", "6"],
-        ]
-        assert g.nodes.type_filter(["a"]).neighbours.type_filter(
-            ["c"]
-        ).neighbours.name.collect() == [[], ["4", "6"]]
-        assert g.nodes.type_filter(["a"]).neighbours.type_filter(
-            ["d"]
-        ).neighbours.name.collect() == [[], []]
-
-        assert g.node("2").neighbours.type_filter(["b"]).name.collect() == ["3"]
-        assert g.node("2").neighbours.type_filter(["d"]).name.collect() == []
-        assert g.node("2").neighbours.type_filter([]).name.collect() == []
-        assert g.node("2").neighbours.type_filter(["c", "a"]).name.collect() == [
-            "1",
-            "4",
-        ]
-        assert g.node("2").neighbours.type_filter(["c"]).neighbours.name.collect() == []
-        assert g.node("2").neighbours.neighbours.name.collect() == [
-            "2",
-            "2",
-            "6",
-            "2",
-            "5",
-        ]
+    assert g.nodes.type_filter(["d"]).neighbours.name.collect() == []
+    assert dict(
+        zip(
+            g.nodes.type_filter(["a"]).id,
+            (sorted(v) for v in g.nodes.type_filter(["a"]).neighbours.name),
+        )
+    ) == {
+        1: ["2"],
+        4: ["2", "5"],
+    }
+    assert dict(
+        zip(
+            g.nodes.type_filter(["a", "c"]).id,
+            (sorted(v) for v in g.nodes.type_filter(["a", "c"]).neighbours.name),
+        )
+    ) == {
+        1: ["2"],
+        4: ["2", "5"],
+        5: ["4", "6"],
+    }
 
-    check(g)
+    assert dict(
+        zip(
+            g.nodes.type_filter(["a"]).id,
+            g.nodes.type_filter(["a"]).neighbours.type_filter(["c"]).name.collect(),
+        )
+    ) == {
+        1: [],
+        4: ["5"],
+    }
+    assert g.nodes.type_filter(["a"]).neighbours.type_filter([]).name.collect() == [
+        [],
+        [],
+    ]
+    assert dict(
+        zip(
+            g.nodes.type_filter(["a"]).id,
+            (
+                sorted(v)
+                for v in g.nodes.type_filter(["a"])
+                .neighbours.type_filter(["b", "c"])
+                .name
+            ),
+        )
+    ) == {1: ["2"], 4: ["2", "5"]}
+    assert g.nodes.type_filter(["a"]).neighbours.type_filter(["d"]).name.collect() == [
+        [],
+        [],
+    ]
+    assert dict(
+        zip(
+            g.nodes.type_filter(["a"]).id,
+            (sorted(v) for v in g.nodes.type_filter(["a"]).neighbours.neighbours.name),
+        )
+    ) == {
+        1: ["1", "3", "4"],
+        4: ["1", "3", "4", "4", "6"],
+    }
+    assert dict(
+        zip(
+            g.nodes.type_filter(["a"]).id,
+            (
+                sorted(v)
+                for v in g.nodes.type_filter(["a"])
+                .neighbours.type_filter(["c"])
+                .neighbours.name
+            ),
+        )
+    ) == {1: [], 4: ["4", "6"]}
+    assert g.nodes.type_filter(["a"]).neighbours.type_filter(
+        ["d"]
+    ).neighbours.name.collect() == [[], []]
+
+    assert g.node("2").neighbours.type_filter(["b"]).name.collect() == ["3"]
+    assert g.node("2").neighbours.type_filter(["d"]).name.collect() == []
+    assert g.node("2").neighbours.type_filter([]).name.collect() == []
+    assert sorted(g.node("2").neighbours.type_filter(["c", "a"]).name.collect()) == [
+        "1",
+        "4",
+    ]
+    assert g.node("2").neighbours.type_filter(["c"]).neighbours.name.collect() == []
+    assert sorted(g.node("2").neighbours.neighbours.name.collect()) == [
+        "2",
+        "2",
+        "2",
+        "5",
+        "6",
+    ]
 
 
 def test_time_exploded_edges():
@@ -2827,24 +2842,16 @@ def test_leading_zeroes_ids():
     g.add_node(0, "001")
     g.add_node(0, "0001")
 
-    @with_disk_graph
-    def check(g):
-        assert g.count_nodes() == 4
-        assert g.nodes.name.collect() == ["1", "01", "001", "0001"]
-
-    check(g)
+    assert g.count_nodes() == 4
+    assert sorted(g.nodes.name.collect()) == ["0001", "001", "01", "1"]
 
     g = Graph()
     g.add_node(0, 0)
     g.add_node(1, 0)
 
-    # @with_disk_graph # FIXME: need special handling for nodes additions from Graph
-    def check(g):
-        check_arr(g.node(0).history.t.collect(), [0, 1])
-        check_arr(g.node("0").history.t.collect(), [0, 1])
-        assert g.nodes.name.collect() == ["0"]
-
-    check(g)
+    check_arr(g.node(0).history.t.collect(), [0, 1])
+    check_arr(g.node("0").history.t.collect(), [0, 1])
+    assert g.nodes.name.collect() == ["0"]
 
 
 def test_node_types():
diff --git a/python/tests/test_base_install/test_graphdb/test_graphdb_imports.py b/python/tests/test_base_install/test_graphdb/test_graphdb_imports.py
index c0aa8624b0..d26463370e 100644
--- a/python/tests/test_base_install/test_graphdb/test_graphdb_imports.py
+++ b/python/tests/test_base_install/test_graphdb/test_graphdb_imports.py
@@ -300,7 +300,7 @@ def test_import_edges():
     g2 = Graph()
     g2.import_edges(g.edges)
     assert g2.count_edges() == 3
-    assert g.edges.id == g2.edges.id
+    assert sorted(g.edges.id) == sorted(g2.edges.id)
 
 
 def test_import_edges_iterator():
@@ -314,4 +314,4 @@ def test_import_edges_iterator():
     g2 = Graph()
     g2.import_edges(iter(g.edges))
     assert g2.count_edges() == 3
-    assert g.edges.id == g2.edges.id
+    assert sorted(g.edges.id) == sorted(g2.edges.id)
diff --git a/python/tests/test_base_install/test_graphdb/test_latest_graph.py b/python/tests/test_base_install/test_graphdb/test_latest_graph.py
index a3e63c3ec3..6262fd9119 100644
--- a/python/tests/test_base_install/test_graphdb/test_latest_graph.py
+++ b/python/tests/test_base_install/test_graphdb/test_latest_graph.py
@@ -117,46 +117,112 @@ def test_persistent_edge_latest():
 
     assert wg.edge(1, 4).latest().is_active()
 
-    assert g.edges.latest().earliest_time.collect() == [6, 6, None]
-    assert g.edges.latest().latest_time.collect() == [6, 6, None]
-
-    assert g.edges.latest().is_active().collect() == [False, True, False]
-    assert g.edges.latest().is_deleted().collect() == [False, False, True]
-    assert g.edges.latest().is_valid().collect() == [True, True, False]
+    assert dict(zip(g.edges.id, g.edges.latest().earliest_time.collect())) == {
+        (1, 2): 6,
+        (1, 3): 6,
+        (1, 4): None,
+    }
+    assert dict(zip(g.edges.id, g.edges.latest().latest_time.collect())) == {
+        (1, 2): 6,
+        (1, 3): 6,
+        (1, 4): None,
+    }
+
+    assert dict(zip(g.edges.id, g.edges.latest().is_active().collect())) == {
+        (1, 2): False,
+        (1, 3): True,
+        (1, 4): False,
+    }
+    assert dict(zip(g.edges.id, g.edges.latest().is_deleted().collect())) == {
+        (1, 2): False,
+        (1, 3): False,
+        (1, 4): True,
+    }
+    assert dict(zip(g.edges.id, g.edges.latest().is_valid().collect())) == {
+        (1, 2): True,
+        (1, 3): True,
+        (1, 4): False,
+    }
 
     assert wg.edges.latest().earliest_time.collect() == [5, 5, 5]
     assert wg.edges.latest().latest_time.collect() == [5, 5, 5]
-    assert wg.edges.latest().is_active().collect() == [False, True, True]
-    assert wg.edges.latest().is_deleted().collect() == [False, False, False]
+    assert dict(zip(g.edges.id, wg.edges.latest().is_active().collect())) == {
+        (1, 2): False,
+        (1, 3): True,
+        (1, 4): True,
+    }
+    assert dict(zip(g.edges.id, wg.edges.latest().is_deleted().collect())) == {
+        (1, 2): False,
+        (1, 3): False,
+        (1, 4): False,
+    }
     assert wg.edges.latest().is_valid().collect() == [True, True, True]
 
-    assert g.nodes.edges.latest().earliest_time.collect() == [
-        [6, 6, None],
-        [6],
-        [6],
-        [None],
-    ]
-    assert g.nodes.edges.latest().latest_time.collect() == [
-        [6, 6, None],
-        [6],
-        [6],
-        [None],
-    ]
-    assert g.nodes.edges.latest().is_active().collect() == [
-        [False, True, False],
-        [False],
-        [True],
-        [False],
-    ]
-
-    assert wg.nodes.edges.latest().earliest_time.collect() == [[5, 5, 5], [5], [5], [5]]
-    assert wg.nodes.edges.latest().latest_time.collect() == [[5, 5, 5], [5], [5], [5]]
-    assert wg.nodes.edges.latest().is_active().collect() == [
-        [False, True, True],
-        [False],
-        [True],
-        [True],
-    ]
+    res = {
+        n.id: {e: v for e, v in zip(n.edges.id, ev)}
+        for n, ev in zip(g.nodes, g.nodes.edges.latest().earliest_time.collect())
+    }
+    assert res == {
+        1: {(1, 2): 6, (1, 3): 6, (1, 4): None},
+        2: {(1, 2): 6},
+        3: {(1, 3): 6},
+        4: {(1, 4): None},
+    }
+
+    res = {
+        n.id: {e: v for e, v in zip(n.edges.id, ev)}
+        for n, ev in zip(g.nodes, g.nodes.edges.latest().latest_time.collect())
+    }
+    assert res == {
+        1: {(1, 2): 6, (1, 3): 6, (1, 4): None},
+        2: {(1, 2): 6},
+        3: {(1, 3): 6},
+        4: {(1, 4): None},
+    }
+
+    res = {
+        n.id: {e: v for e, v in zip(n.edges.id, ev)}
+        for n, ev in zip(g.nodes, g.nodes.edges.latest().is_active().collect())
+    }
+    assert res == {
+        1: {(1, 2): False, (1, 3): True, (1, 4): False},
+        2: {(1, 2): False},
+        3: {(1, 3): True},
+        4: {(1, 4): False},
+    }
+
+    res = {
+        n.id: {e: v for e, v in zip(n.edges.id, ev)}
+        for n, ev in zip(g.nodes, wg.nodes.edges.latest().earliest_time.collect())
+    }
+    assert res == {
+        1: {(1, 2): 5, (1, 3): 5, (1, 4): 5},
+        2: {(1, 2): 5},
+        3: {(1, 3): 5},
+        4: {(1, 4): 5},
+    }
+
+    res = {
+        n.id: {e: v for e, v in zip(n.edges.id, ev)}
+        for n, ev in zip(g.nodes, wg.nodes.edges.latest().latest_time.collect())
+    }
+    assert res == {
+        1: {(1, 2): 5, (1, 3): 5, (1, 4): 5},
+        2: {(1, 2): 5},
+        3: {(1, 3): 5},
+        4: {(1, 4): 5},
+    }
+
+    res = {
+        n.id: {e: v for e, v in zip(n.edges.id, ev)}
+        for n, ev in zip(g.nodes, wg.nodes.edges.latest().is_active().collect())
+    }
+    assert res == {
+        1: {(1, 2): False, (1, 3): True, (1, 4): True},
+        2: {(1, 2): False},
+        3: {(1, 3): True},
+        4: {(1, 4): True},
+    }
 
 
 def test_persistent_node_latest():
diff --git a/python/tests/test_base_install/test_graphql/edit_graph/test_archive_graph.py b/python/tests/test_base_install/test_graphql/edit_graph/test_archive_graph.py
index 858dd15f30..64abdc470e 100644
--- a/python/tests/test_base_install/test_graphql/edit_graph/test_archive_graph.py
+++ b/python/tests/test_base_install/test_graphql/edit_graph/test_archive_graph.py
@@ -21,7 +21,7 @@ def test_archive_graph_fails_if_graph_not_found():
                 }"""
         with pytest.raises(Exception) as excinfo:
             client.query(query)
-        assert "Graph not found" in str(excinfo.value)
+        assert "Graph 'g1' does not exist" in str(excinfo.value)
 
 
 def test_archive_graph_fails_if_graph_not_found_at_namespace():
@@ -38,7 +38,7 @@ def test_archive_graph_fails_if_graph_not_found_at_namespace():
                 }"""
         with pytest.raises(Exception) as excinfo:
             client.query(query)
-        assert "Graph not found" in str(excinfo.value)
+        assert "Graph 'shivam/g1' does not exist" in str(excinfo.value)
 
 
 def test_archive_graph_succeeds():
diff --git a/python/tests/test_base_install/test_graphql/edit_graph/test_copy_graph.py b/python/tests/test_base_install/test_graphql/edit_graph/test_copy_graph.py
index 3d72683421..734e08cce9 100644
--- a/python/tests/test_base_install/test_graphql/edit_graph/test_copy_graph.py
+++ b/python/tests/test_base_install/test_graphql/edit_graph/test_copy_graph.py
@@ -20,7 +20,7 @@ def test_copy_graph_fails_if_graph_not_found():
         }"""
         with pytest.raises(Exception) as excinfo:
             client.query(query)
-        assert "Graph not found" in str(excinfo.value)
+        assert "Graph 'ben/g5' does not exist" in str(excinfo.value)
 
 
 def test_copy_graph_fails_if_graph_with_same_name_already_exists():
@@ -45,7 +45,7 @@ def test_copy_graph_fails_if_graph_with_same_name_already_exists():
         }"""
         with pytest.raises(Exception) as excinfo:
             client.query(query)
-        assert "Graph already exists by name" in str(excinfo.value)
+        assert "Graph 'g6' already exists" in str(excinfo.value)
 
 
 def test_copy_graph_fails_if_graph_with_same_name_already_exists_at_same_namespace_as_graph():
@@ -70,7 +70,7 @@ def test_copy_graph_fails_if_graph_with_same_name_already_exists_at_same_namespa
         }"""
         with pytest.raises(Exception) as excinfo:
             client.query(query)
-        assert "Graph already exists by name" in str(excinfo.value)
+        assert "Graph 'ben/g6' already exists" in str(excinfo.value)
 
 
 def test_copy_graph_fails_if_graph_with_same_name_already_exists_at_diff_namespace_as_graph():
@@ -96,7 +96,7 @@ def test_copy_graph_fails_if_graph_with_same_name_already_exists_at_diff_namespa
         }"""
         with pytest.raises(Exception) as excinfo:
             client.query(query)
-        assert "Graph already exists by name" in str(excinfo.value)
+        assert "Graph 'shivam/g6' already exists" in str(excinfo.value)
 
 
 def test_copy_graph_succeeds():
diff --git a/python/tests/test_base_install/test_graphql/edit_graph/test_delete_graph.py b/python/tests/test_base_install/test_graphql/edit_graph/test_delete_graph.py
index 29b7a1d2b1..7b74574344 100644
--- a/python/tests/test_base_install/test_graphql/edit_graph/test_delete_graph.py
+++ b/python/tests/test_base_install/test_graphql/edit_graph/test_delete_graph.py
@@ -18,7 +18,7 @@ def test_delete_graph_fails_if_graph_not_found():
         }"""
         with pytest.raises(Exception) as excinfo:
             client.query(query)
-        assert "Graph not found" in str(excinfo.value)
+        assert "Graph 'ben/g5' does not exist" in str(excinfo.value)
 
 
 def test_delete_graph_succeeds_if_graph_found():
@@ -30,8 +30,7 @@ def test_delete_graph_succeeds_if_graph_found():
         g.add_edge(1, "ben", "hamza")
         g.add_edge(2, "haaroon", "hamza")
         g.add_edge(3, "ben", "haaroon")
-
-        g.save_to_file(os.path.join(work_dir, "g1"))
+        client.send_graph("g1", g)
 
         query = """mutation {
           deleteGraph(
@@ -43,7 +42,7 @@ def test_delete_graph_succeeds_if_graph_found():
         query = """{graph(path: "g1") {nodes {list {name}}}}"""
         with pytest.raises(Exception) as excinfo:
             client.query(query)
-        assert "Graph not found" in str(excinfo.value)
+        assert "Graph 'g1' does not exist" in str(excinfo.value)
 
 
 def test_delete_graph_using_client_api_succeeds_if_graph_found():
@@ -62,7 +61,7 @@ def test_delete_graph_using_client_api_succeeds_if_graph_found():
         query = """{graph(path: "g1") {nodes {list {name}}}}"""
         with pytest.raises(Exception) as excinfo:
             client.query(query)
-        assert "Graph not found" in str(excinfo.value)
+        assert "Graph 'g1' does not exist" in str(excinfo.value)
 
 
 def test_delete_graph_succeeds_if_graph_found_at_namespace():
@@ -87,4 +86,4 @@ def test_delete_graph_succeeds_if_graph_found_at_namespace():
         query = """{graph(path: "g1") {nodes {list {name}}}}"""
         with pytest.raises(Exception) as excinfo:
             client.query(query)
-        assert "Graph not found" in str(excinfo.value)
+        assert "Graph 'g1' does not exist" in str(excinfo.value)
diff --git a/python/tests/test_base_install/test_graphql/edit_graph/test_get_graph.py b/python/tests/test_base_install/test_graphql/edit_graph/test_get_graph.py
index 740278d623..6f22bc0928 100644
--- a/python/tests/test_base_install/test_graphql/edit_graph/test_get_graph.py
+++ b/python/tests/test_base_install/test_graphql/edit_graph/test_get_graph.py
@@ -16,7 +16,7 @@ def test_get_graph_fails_if_graph_not_found():
         query = """{ graph(path: "g1") { name, path, nodes { list { name } } } }"""
         with pytest.raises(Exception) as excinfo:
             client.query(query)
-        assert "Graph not found" in str(excinfo.value)
+        assert "Graph 'g1' does not exist" in str(excinfo.value)
 
 
 def test_get_graph_fails_if_graph_not_found_at_namespace():
@@ -29,7 +29,7 @@ def test_get_graph_fails_if_graph_not_found_at_namespace():
         )
         with pytest.raises(Exception) as excinfo:
             client.query(query)
-        assert "Graph not found" in str(excinfo.value)
+        assert "Graph 'shivam/g1' does not exist" in str(excinfo.value)
 
 
 def test_get_graph_succeeds_if_graph_found():
diff --git a/python/tests/test_base_install/test_graphql/edit_graph/test_graphql.py b/python/tests/test_base_install/test_graphql/edit_graph/test_graphql.py
index 3f21bdca32..9c0f624be9 100644
--- a/python/tests/test_base_install/test_graphql/edit_graph/test_graphql.py
+++ b/python/tests/test_base_install/test_graphql/edit_graph/test_graphql.py
@@ -1,18 +1,16 @@
+import json
 import os
 import tempfile
-
 import pytest
-
+from utils import sort_by_gql_name_or_id
+from raphtory import Graph, graph_loader
 from raphtory.graphql import (
     GraphServer,
     RaphtoryClient,
-    encode_graph,
-    decode_graph,
     RemoteGraph,
+    decode_graph,
+    encode_graph,
 )
-from raphtory import graph_loader
-from raphtory import Graph
-import json
 
 
 def normalize_path(path):
@@ -156,39 +154,47 @@ def assert_graph_fetch(path):
         path = "../shivam/g"
         with pytest.raises(Exception) as excinfo:
             client.send_graph(path=path, graph=g, overwrite=True)
-        assert "References to the parent dir are not allowed within the path:" in str(
-            excinfo.value
+        assert (
+            "Invalid path '../shivam/g': References to the parent dir are not allowed within the path"
+            in str(excinfo.value)
         )
 
         path = "./shivam/g"
         with pytest.raises(Exception) as excinfo:
             client.send_graph(path=path, graph=g, overwrite=True)
-        assert "References to the current dir are not allowed within the path" in str(
-            excinfo.value
+        assert (
+            "Invalid path './shivam/g': References to the current dir are not allowed within the path"
+            in str(excinfo.value)
         )
 
         path = "shivam/../../../../investigation/g"
         with pytest.raises(Exception) as excinfo:
             client.send_graph(path=path, graph=g, overwrite=True)
-        assert "References to the parent dir are not allowed within the path:" in str(
-            excinfo.value
+        assert (
+            "Invalid path 'shivam/../../../../investigation/g': References to the parent dir are not allowed within the path"
+            in str(excinfo.value)
         )
 
         path = "//shivam/investigation/g"
         with pytest.raises(Exception) as excinfo:
             client.send_graph(path=path, graph=g, overwrite=True)
-        assert "Double forward slashes are not allowed in path" in str(excinfo.value)
+        assert (
+            "Invalid path '//shivam/investigation/g': Double forward slashes are not allowed in path"
+            in str(excinfo.value)
+        )
 
         path = "shivam/investigation//2024-12-12/g"
         with pytest.raises(Exception) as excinfo:
             client.send_graph(path=path, graph=g, overwrite=True)
-        assert "Double forward slashes are not allowed in path" in str(excinfo.value)
+        assert (
+            "Invalid path 'shivam/investigation//2024-12-12/g': Double forward slashes are not allowed in path"
+            in str(excinfo.value)
+        )
 
         path = r"shivam/investigation\2024-12-12"
         with pytest.raises(Exception) as excinfo:
             client.send_graph(path=path, graph=g, overwrite=True)
-        assert "Backslash not allowed in path" in str(excinfo.value)
-
+        assert r"Backslash not allowed in path" in str(excinfo.value)
         # Test if we can escape through a symlink
         tmp_dir2 = tempfile.mkdtemp()
         nested_dir = os.path.join(tmp_work_dir, "shivam", "graphs")
@@ -199,7 +205,10 @@ def assert_graph_fetch(path):
         path = "shivam/graphs/not_a_symlink_i_promise/escaped"
         with pytest.raises(Exception) as excinfo:
             client.send_graph(path=path, graph=g, overwrite=True)
-        assert "A component of the given path was a symlink" in str(excinfo.value)
+        assert (
+            "Invalid path 'shivam/graphs/not_a_symlink_i_promise/escaped': A component of the given path was a symlink"
+            in str(excinfo.value)
+        )
 
 
 def test_graph_windows_and_layers_query():
@@ -479,13 +488,11 @@ def test_create_node():
         assert client.query(create_node_query) == {
             "updateGraph": {"createNode": {"success": True}}
         }
-        assert client.query(query_nodes) == {
-            "graph": {
-                "nodes": {
-                    "list": [{"name": "ben"}, {"name": "shivam"}, {"name": "oogway"}]
-                }
-            }
-        }
+        nodes = sorted(
+            n["name"] for n in client.query(query_nodes)["graph"]["nodes"]["list"]
+        )
+        expected_nodes = ["ben", "oogway", "shivam"]
+        assert nodes == expected_nodes
 
         with pytest.raises(Exception) as excinfo:
             client.query(create_node_query)
@@ -509,13 +516,11 @@ def test_create_node_using_client():
 
         remote_graph = client.remote_graph(path="g")
         remote_graph.create_node(timestamp=0, id="oogway")
-        assert client.query(query_nodes) == {
-            "graph": {
-                "nodes": {
-                    "list": [{"name": "ben"}, {"name": "shivam"}, {"name": "oogway"}]
-                }
-            }
-        }
+        nodes = sorted(
+            n["name"] for n in client.query(query_nodes)["graph"]["nodes"]["list"]
+        )
+        expected_nodes = ["ben", "oogway", "shivam"]
+        assert nodes == expected_nodes
 
         with pytest.raises(Exception) as excinfo:
             remote_graph.create_node(timestamp=0, id="oogway")
@@ -664,30 +669,25 @@ def test_create_node_using_client_with_node_type():
         client.send_graph(path="g", graph=g)
 
         query_nodes = """{graph(path: "g") {nodes {list {name, nodeType}}}}"""
-        assert client.query(query_nodes) == {
-            "graph": {
-                "nodes": {
-                    "list": [
-                        {"name": "ben", "nodeType": None},
-                        {"name": "shivam", "nodeType": None},
-                    ]
-                }
-            }
-        }
+
+        node_and_types = sorted(
+            client.query(query_nodes)["graph"]["nodes"]["list"], key=lambda n: n["name"]
+        )
+        assert node_and_types == [
+            {"name": "ben", "nodeType": None},
+            {"name": "shivam", "nodeType": None},
+        ]
 
         remote_graph = client.remote_graph(path="g")
         remote_graph.create_node(timestamp=0, id="oogway", node_type="master")
-        assert client.query(query_nodes) == {
-            "graph": {
-                "nodes": {
-                    "list": [
-                        {"name": "ben", "nodeType": None},
-                        {"name": "shivam", "nodeType": None},
-                        {"name": "oogway", "nodeType": "master"},
-                    ]
-                }
-            }
-        }
+        node_and_types = sorted(
+            client.query(query_nodes)["graph"]["nodes"]["list"], key=lambda n: n["name"]
+        )
+        assert node_and_types == [
+            {"name": "ben", "nodeType": None},
+            {"name": "oogway", "nodeType": "master"},
+            {"name": "shivam", "nodeType": None},
+        ]
 
         with pytest.raises(Exception) as excinfo:
             remote_graph.create_node(timestamp=0, id="oogway", node_type="master")
@@ -707,7 +707,7 @@ def test_edge_id():
         client.send_graph(path="g", graph=g)
 
         query_nodes = """{graph(path: "g") {edges {list {id}}}}"""
-        assert client.query(query_nodes) == {
+        assert sort_by_gql_name_or_id(client.query(query_nodes)) == {
             "graph": {
                 "edges": {
                     "list": [
@@ -720,6 +720,154 @@ def test_edge_id():
         }
 
 
+def test_graph_persistence_across_restarts():
+    tmp_work_dir = tempfile.mkdtemp()
+
+    # First server session: create graph with 3 nodes and 2 edges
+    with GraphServer(tmp_work_dir).start(port=1738):
+        client = RaphtoryClient("http://localhost:1738")
+        client.new_graph(path="persistent_graph", graph_type="EVENT")
+        remote_graph = client.remote_graph(path="persistent_graph")
+        # Create 3 nodes
+        remote_graph.add_node(timestamp=1, id="node1")
+        remote_graph.add_node(timestamp=2, id="node2")
+        remote_graph.add_node(timestamp=3, id="node3")
+
+        # Create 2 edges
+        remote_graph.add_edge(timestamp=4, src="node1", dst="node2")
+        remote_graph.add_edge(timestamp=5, src="node2", dst="node3")
+
+        # Verify initial creation
+        query_nodes = """{graph(path: "persistent_graph") {nodes {list {name}}}}"""
+        query_edges = """{graph(path: "persistent_graph") {edges {list {id}}}}"""
+
+        assert sort_by_gql_name_or_id(client.query(query_nodes)) == {
+            "graph": {
+                "nodes": {
+                    "list": [{"name": "node1"}, {"name": "node2"}, {"name": "node3"}]
+                }
+            }
+        }
+
+        assert sort_by_gql_name_or_id(client.query(query_edges)) == {
+            "graph": {
+                "edges": {
+                    "list": [
+                        {"id": ["node1", "node2"]},
+                        {"id": ["node2", "node3"]},
+                    ]
+                }
+            }
+        }
+
+    # Server is now shutdown, start it again
+    with GraphServer(tmp_work_dir).start(port=1738):
+        client = RaphtoryClient("http://localhost:1738")
+
+        # Verify persistence: check that nodes and edges are still there
+        query_nodes = """{graph(path: "persistent_graph") {nodes {sorted (sortBys: [{id: true}]){ list {name} }}}}"""
+        query_edges = """{graph(path: "persistent_graph") {edges {sorted (sortBys: [{src: true, dst: true}]){ list {id} }}}}"""
+
+        assert client.query(query_nodes) == {
+            "graph": {
+                "nodes": {
+                    "sorted": {
+                        "list": [
+                            {"name": "node1"},
+                            {"name": "node2"},
+                            {"name": "node3"},
+                        ]
+                    }
+                }
+            }
+        }
+
+        assert client.query(query_edges) == {
+            "graph": {
+                "edges": {
+                    "sorted": {
+                        "list": [
+                            {"id": ["node1", "node2"]},
+                            {"id": ["node2", "node3"]},
+                        ]
+                    }
+                }
+            }
+        }
+
+        # Add one more node and another edge
+        remote_graph = client.remote_graph(path="persistent_graph")
+        remote_graph.add_node(timestamp=6, id="node4")
+        remote_graph.add_edge(timestamp=7, src="node3", dst="node4")
+
+        # Verify the new additions
+        assert client.query(query_nodes) == {
+            "graph": {
+                "nodes": {
+                    "sorted": {
+                        "list": [
+                            {"name": "node1"},
+                            {"name": "node2"},
+                            {"name": "node3"},
+                            {"name": "node4"},
+                        ]
+                    }
+                }
+            }
+        }
+
+        assert client.query(query_edges) == {
+            "graph": {
+                "edges": {
+                    "sorted": {
+                        "list": [
+                            {"id": ["node1", "node2"]},
+                            {"id": ["node2", "node3"]},
+                            {"id": ["node3", "node4"]},
+                        ]
+                    }
+                }
+            }
+        }
+
+
+# tests for https://github.com/Pometry/Raphtory/issues/2487
+def test_float_is_stable_on_roundtrip():
+    tmp_work_dir = tempfile.mkdtemp()
+    float_examples = [
+        -1.5186248156922167e66,
+        -1.7177476606208664e199,
+        -1.048551606005279e71,
+    ]
+    prop_key = "p"
+
+    with GraphServer(tmp_work_dir).start(port=1738):
+        client = RaphtoryClient("http://localhost:1738")
+        client.new_graph(path="g", graph_type="EVENT")
+        remote_graph = client.remote_graph(path="g")
+
+        for i, num in enumerate(float_examples):
+            remote_graph.add_node(timestamp=i, id=i, properties={prop_key: num})
+            query = f"""
+                query {{
+                  graph(path: "g") {{
+                    node(name: "{i}") {{
+                      at(time: {i}) {{
+                        properties {{
+                          get(key: "p") {{
+                            value
+                          }}
+                        }}
+                      }}
+                    }}
+                  }}
+                }}
+            """
+            resp = client.query(query)
+            retrieved_float = resp["graph"]["node"]["at"]["properties"]["get"]["value"]
+            assert retrieved_float == num
+
+
 # def test_disk_graph_name():
 #     import pandas as pd
 #     from raphtory import DiskGraphStorage
diff --git a/python/tests/test_base_install/test_graphql/edit_graph/test_move_graph.py b/python/tests/test_base_install/test_graphql/edit_graph/test_move_graph.py
index 98eb97d4bf..f72762e3d8 100644
--- a/python/tests/test_base_install/test_graphql/edit_graph/test_move_graph.py
+++ b/python/tests/test_base_install/test_graphql/edit_graph/test_move_graph.py
@@ -20,7 +20,7 @@ def test_move_graph_fails_if_graph_not_found():
         }"""
         with pytest.raises(Exception) as excinfo:
             client.query(query)
-        assert "Graph not found" in str(excinfo.value)
+        assert "Graph 'ben/g5' does not exist" in str(excinfo.value)
 
 
 def test_move_graph_fails_if_graph_with_same_name_already_exists():
@@ -45,7 +45,7 @@ def test_move_graph_fails_if_graph_with_same_name_already_exists():
         }"""
         with pytest.raises(Exception) as excinfo:
             client.query(query)
-        assert "Graph already exists by name" in str(excinfo.value)
+        assert "Graph 'g6' already exists" in str(excinfo.value)
 
 
 def test_move_graph_fails_if_graph_with_same_name_already_exists_at_same_namespace_as_graph():
@@ -70,7 +70,7 @@ def test_move_graph_fails_if_graph_with_same_name_already_exists_at_same_namespa
         }"""
         with pytest.raises(Exception) as excinfo:
             client.query(query)
-        assert "Graph already exists by name" in str(excinfo.value)
+        assert "Graph 'ben/g6' already exists" in str(excinfo.value)
 
 
 def test_move_graph_fails_if_graph_with_same_name_already_exists_at_diff_namespace_as_graph():
@@ -96,7 +96,7 @@ def test_move_graph_fails_if_graph_with_same_name_already_exists_at_diff_namespa
         }"""
         with pytest.raises(Exception) as excinfo:
             client.query(query)
-        assert "Graph already exists by name" in str(excinfo.value)
+        assert "Graph 'shivam/g6' already exists" in str(excinfo.value)
 
 
 def test_move_graph_succeeds():
@@ -124,7 +124,7 @@ def test_move_graph_succeeds():
         query = """{graph(path: "shivam/g3") {nodes {list {name}}}}"""
         with pytest.raises(Exception) as excinfo:
             client.query(query)
-        assert "Graph not found" in str(excinfo.value)
+        assert "Graph 'shivam/g3' does not exist" in str(excinfo.value)
 
         query = """{graph(path: "g4") {
                 nodes {list {name}}
@@ -157,7 +157,7 @@ def test_move_graph_using_client_api_succeeds():
         query = """{graph(path: "shivam/g3") {nodes {list {name}}}}"""
         with pytest.raises(Exception) as excinfo:
             client.query(query)
-        assert "Graph not found" in str(excinfo.value)
+        assert "Graph 'shivam/g3' does not exist" in str(excinfo.value)
 
         query = """{graph(path: "ben/g4") {
                 nodes {list {name}}
@@ -197,7 +197,7 @@ def test_move_graph_succeeds_at_same_namespace_as_graph():
         query = """{graph(path: "shivam/g3") {nodes {list {name}}}}"""
         with pytest.raises(Exception) as excinfo:
             client.query(query)
-        assert "Graph not found" in str(excinfo.value)
+        assert "Graph 'shivam/g3' does not exist" in str(excinfo.value)
 
         query = """{graph(path: "shivam/g4") {
                 nodes {list {name}}
@@ -238,7 +238,7 @@ def test_move_graph_succeeds_at_diff_namespace_as_graph():
         query = """{graph(path: "ben/g3") {nodes {list {name}}}}"""
         with pytest.raises(Exception) as excinfo:
             client.query(query)
-        assert "Graph not found" in str(excinfo.value)
+        assert "Graph 'ben/g3' does not exist" in str(excinfo.value)
 
         query = """{graph(path: "shivam/g4") {
                 nodes {list {name}}
diff --git a/python/tests/test_base_install/test_graphql/edit_graph/test_new_graph.py b/python/tests/test_base_install/test_graphql/edit_graph/test_new_graph.py
index da0d3f6c9d..adba406a92 100644
--- a/python/tests/test_base_install/test_graphql/edit_graph/test_new_graph.py
+++ b/python/tests/test_base_install/test_graphql/edit_graph/test_new_graph.py
@@ -45,7 +45,7 @@ def test_new_graph_fails_if_graph_found():
         }"""
         with pytest.raises(Exception) as excinfo:
             client.query(query)
-        assert "Graph already exists by name" in str(excinfo.value)
+        assert "Graph 'test/path/g1' already exists" in str(excinfo.value)
 
 
 def test_client_new_graph_works():
diff --git a/python/tests/test_base_install/test_graphql/edit_graph/test_receive_graph.py b/python/tests/test_base_install/test_graphql/edit_graph/test_receive_graph.py
index 2230da5948..20bc5ce76a 100644
--- a/python/tests/test_base_install/test_graphql/edit_graph/test_receive_graph.py
+++ b/python/tests/test_base_install/test_graphql/edit_graph/test_receive_graph.py
@@ -16,7 +16,7 @@ def test_receive_graph_fails_if_no_graph_found():
         query = """{ receiveGraph(path: "g2") }"""
         with pytest.raises(Exception) as excinfo:
             client.query(query)
-        assert "Graph not found" in str(excinfo.value)
+        assert "Graph 'g2' does not exist" in str(excinfo.value)
 
 
 def test_receive_graph_succeeds_if_graph_found():
@@ -28,13 +28,11 @@ def test_receive_graph_succeeds_if_graph_found():
         g.add_edge(1, "ben", "hamza")
         g.add_edge(2, "haaroon", "hamza")
         g.add_edge(3, "ben", "haaroon")
-
-        g.save_to_file(os.path.join(work_dir, "g1"))
-
+        client.send_graph("g1", g)
         query = """{ receiveGraph(path: "g1") }"""
         received_graph = client.query(query)["receiveGraph"]
 
-        decoded_bytes = base64.b64decode(received_graph)
+        decoded_bytes = base64.urlsafe_b64decode(received_graph)
         g = Graph.deserialise(decoded_bytes)
         assert g.nodes.name == ["ben", "hamza", "haaroon"]
 
@@ -62,7 +60,7 @@ def test_receive_graph_fails_if_no_graph_found_at_namespace():
         query = """{ receiveGraph(path: "shivam/g2") }"""
         with pytest.raises(Exception) as excinfo:
             client.query(query)
-        assert "Graph not found" in str(excinfo.value)
+        assert "Graph 'shivam/g2' does not exist" in str(excinfo.value)
 
 
 def test_receive_graph_succeeds_if_graph_found_at_namespace():
@@ -81,7 +79,7 @@ def test_receive_graph_succeeds_if_graph_found_at_namespace():
         query = """{ receiveGraph(path: "shivam/g2") }"""
         received_graph = client.query(query)["receiveGraph"]
 
-        decoded_bytes = base64.b64decode(received_graph)
+        decoded_bytes = base64.urlsafe_b64decode(received_graph)
 
         g = Graph.deserialise(decoded_bytes)
         assert g.nodes.name == ["ben", "hamza", "haaroon"]
diff --git a/python/tests/test_base_install/test_graphql/edit_graph/test_send_graph.py b/python/tests/test_base_install/test_graphql/edit_graph/test_send_graph.py
index d73703d88a..41a469f31f 100644
--- a/python/tests/test_base_install/test_graphql/edit_graph/test_send_graph.py
+++ b/python/tests/test_base_install/test_graphql/edit_graph/test_send_graph.py
@@ -31,7 +31,7 @@ def test_send_graph_fails_if_graph_already_exists():
         client = RaphtoryClient("http://localhost:1736")
         with pytest.raises(Exception) as excinfo:
             client.send_graph(path="g", graph=g)
-        assert "Graph already exists by name = g" in str(excinfo.value)
+        assert "Graph 'g' already exists" in str(excinfo.value)
 
 
 def test_send_graph_succeeds_if_graph_already_exists_with_overwrite_enabled():
@@ -41,11 +41,12 @@ def test_send_graph_succeeds_if_graph_already_exists_with_overwrite_enabled():
     g.add_edge(1, "ben", "hamza")
     g.add_edge(2, "haaroon", "hamza")
     g.add_edge(3, "ben", "haaroon")
-    g.save_to_file(os.path.join(tmp_work_dir, "g"))
 
     with GraphServer(tmp_work_dir).start():
         client = RaphtoryClient("http://localhost:1736")
 
+        client.send_graph(path="g", graph=g)
+
         g = Graph()
         g.add_edge(1, "ben", "hamza")
         g.add_edge(2, "haaroon", "hamza")
@@ -94,7 +95,7 @@ def test_send_graph_fails_if_graph_already_exists_at_namespace():
         client = RaphtoryClient("http://localhost:1736")
         with pytest.raises(Exception) as excinfo:
             client.send_graph(path="shivam/g", graph=g)
-        assert "Graph already exists by name" in str(excinfo.value)
+        assert "Graph 'shivam/g' already exists" in str(excinfo.value)
 
 
 def test_send_graph_succeeds_if_graph_already_exists_at_namespace_with_overwrite_enabled():
diff --git a/python/tests/test_base_install/test_graphql/edit_graph/test_upload_graph.py b/python/tests/test_base_install/test_graphql/edit_graph/test_upload_graph.py
index 78e7e7ac1b..5f92d5e37a 100644
--- a/python/tests/test_base_install/test_graphql/edit_graph/test_upload_graph.py
+++ b/python/tests/test_base_install/test_graphql/edit_graph/test_upload_graph.py
@@ -70,7 +70,7 @@ def test_upload_graph_fails_if_graph_already_exists():
         client = RaphtoryClient("http://localhost:1736")
         with pytest.raises(Exception) as excinfo:
             client.upload_graph(path="g", file_path=g_file_path)
-        assert "Graph already exists by name" in str(excinfo.value)
+        assert "Graph 'g' already exists" in str(excinfo.value)
 
 
 def test_upload_graph_succeeds_if_graph_already_exists_with_overwrite_enabled():
@@ -135,6 +135,8 @@ def test_upload_graph_succeeds_if_no_graph_found_with_same_name_at_namespace():
                 }
             }
         }
+        g2 = client.receive_graph("shivam/g")
+    assert g2.has_node("ben")
 
 
 def test_upload_graph_fails_if_graph_already_exists_at_namespace():
@@ -153,7 +155,7 @@ def test_upload_graph_fails_if_graph_already_exists_at_namespace():
         client = RaphtoryClient("http://localhost:1736")
         with pytest.raises(Exception) as excinfo:
             client.upload_graph(path="shivam/g", file_path=g_file_path, overwrite=False)
-        assert "Graph already exists by name" in str(excinfo.value)
+        assert "Graph 'shivam/g' already exists" in str(excinfo.value)
 
 
 def test_upload_graph_succeeds_if_graph_already_exists_at_namespace_with_overwrite_enabled():
diff --git a/python/tests/test_base_install/test_graphql/misc/test_latest.py b/python/tests/test_base_install/test_graphql/misc/test_latest.py
index 967618667f..ee58148aed 100644
--- a/python/tests/test_base_install/test_graphql/misc/test_latest.py
+++ b/python/tests/test_base_install/test_graphql/misc/test_latest.py
@@ -1,3 +1,4 @@
+from utils import sort_by_gql_name_or_id
 from raphtory.graphql import RaphtoryClient
 
 
@@ -49,6 +50,7 @@ def test_latest_and_active():
                 edges {
                   latest {
                     list {
+                      id
                       history {
                         list {
                           timestamp
@@ -74,6 +76,7 @@ def test_latest_and_active():
             edges {
               latest {
                 list {
+                  id
                   history {
                     list {
                       timestamp
@@ -114,15 +117,17 @@ def test_latest_and_active():
                             "latest": {
                                 "list": [
                                     {
+                                        "id": [1, 2],
                                         "history": {
                                             "list": [{"timestamp": 3, "eventId": 2}]
-                                        }
+                                        },
                                     },
-                                    {"history": {"list": []}},
+                                    {"id": [1, 3], "history": {"list": []}},
                                     {
+                                        "id": [1, 4],
                                         "history": {
                                             "list": [{"timestamp": 3, "eventId": 5}]
-                                        }
+                                        },
                                     },
                                 ]
                             }
@@ -134,9 +139,10 @@ def test_latest_and_active():
                             "latest": {
                                 "list": [
                                     {
+                                        "id": [1, 2],
                                         "history": {
                                             "list": [{"timestamp": 3, "eventId": 2}]
-                                        }
+                                        },
                                     }
                                 ]
                             }
@@ -144,7 +150,11 @@ def test_latest_and_active():
                     },
                     {
                         "name": "3",
-                        "edges": {"latest": {"list": [{"history": {"list": []}}]}},
+                        "edges": {
+                            "latest": {
+                                "list": [{"id": [1, 3], "history": {"list": []}}]
+                            }
+                        },
                     },
                     {
                         "name": "4",
@@ -152,9 +162,10 @@ def test_latest_and_active():
                             "latest": {
                                 "list": [
                                     {
+                                        "id": [1, 4],
                                         "history": {
                                             "list": [{"timestamp": 3, "eventId": 5}]
-                                        }
+                                        },
                                     }
                                 ]
                             }
@@ -190,9 +201,15 @@ def test_latest_and_active():
             "edges": {
                 "latest": {
                     "list": [
-                        {"history": {"list": [{"timestamp": 3, "eventId": 2}]}},
-                        {"history": {"list": []}},
-                        {"history": {"list": [{"timestamp": 3, "eventId": 5}]}},
+                        {
+                            "id": [1, 2],
+                            "history": {"list": [{"timestamp": 3, "eventId": 2}]},
+                        },
+                        {"id": [1, 3], "history": {"list": []}},
+                        {
+                            "id": [1, 4],
+                            "history": {"list": [{"timestamp": 3, "eventId": 5}]},
+                        },
                     ]
                 }
             },
@@ -217,4 +234,4 @@ def test_latest_and_active():
     g.save_to_file(work_dir + "/graph")
     with GraphServer(work_dir).start():
         client = RaphtoryClient("http://localhost:1736")
-        assert client.query(query) == result
+        assert sort_by_gql_name_or_id(client.query(query)) == result
diff --git a/python/tests/test_base_install/test_graphql/misc/test_map_props.py b/python/tests/test_base_install/test_graphql/misc/test_map_props.py
index 2b040896fa..f5ca23d73a 100644
--- a/python/tests/test_base_install/test_graphql/misc/test_map_props.py
+++ b/python/tests/test_base_install/test_graphql/misc/test_map_props.py
@@ -13,7 +13,7 @@
 
 def test_map_props():
     work_dir = tempfile.mkdtemp()
-    server = server = GraphServer(work_dir)
+    server = GraphServer(work_dir)
     with server.start():
         temp_dir = tempfile.mkdtemp()
         client = RaphtoryClient("http://localhost:1736")
@@ -27,7 +27,7 @@ def test_map_props():
         check_test_prop(client)
 
     work_dir = tempfile.mkdtemp()
-    server = server = GraphServer(work_dir)
+    server = GraphServer(work_dir)
     with server.start():
         client.new_graph("test", "EVENT")
         rg = client.remote_graph("test")
diff --git a/python/tests/test_base_install/test_graphql/test_apply_views.py b/python/tests/test_base_install/test_graphql/test_apply_views.py
index f417f6b2a6..298b98c73a 100644
--- a/python/tests/test_base_install/test_graphql/test_apply_views.py
+++ b/python/tests/test_base_install/test_graphql/test_apply_views.py
@@ -987,6 +987,7 @@ def test_apply_view_after():
     nodes {
       applyViews(views: [{after: 6}]) {
         list {
+          name
           history {
             timestamps {
               list
@@ -1042,11 +1043,11 @@ def test_apply_view_after():
             "nodes": {
                 "applyViews": {
                     "list": [
-                        {"history": {"timestamps": {"list": []}}},
-                        {"history": {"timestamps": {"list": []}}},
-                        {"history": {"timestamps": {"list": []}}},
-                        {"history": {"timestamps": {"list": []}}},
-                        {"history": {"timestamps": {"list": []}}},
+                        {"name": "1", "history": {"timestamps": {"list": []}}},
+                        {"name": "2", "history": {"timestamps": {"list": []}}},
+                        {"name": "3", "history": {"timestamps": {"list": []}}},
+                        {"name": "6", "history": {"timestamps": {"list": []}}},
+                        {"name": "7", "history": {"timestamps": {"list": []}}},
                     ]
                 }
             },
@@ -1080,7 +1081,7 @@ def test_apply_view_after():
             },
         }
     }
-    run_graphql_test(query, correct, graph)
+    run_graphql_test(query, correct, graph, sort_output=True)
 
 
 def test_apply_view_shrink_window():
@@ -1190,7 +1191,7 @@ def test_apply_view_shrink_window():
             },
         }
     }
-    run_graphql_test(query, correct, graph)
+    run_graphql_test(query, correct, graph, sort_output=True)
 
 
 def test_apply_view_shrink_start():
@@ -1300,7 +1301,7 @@ def test_apply_view_shrink_start():
             },
         }
     }
-    run_graphql_test(query, correct, graph)
+    run_graphql_test(query, correct, graph, sort_output=True)
 
 
 def test_apply_view_shrink_end():
@@ -1412,7 +1413,7 @@ def test_apply_view_shrink_end():
             },
         }
     }
-    run_graphql_test(query, correct, graph)
+    run_graphql_test(query, correct, graph, sort_output=True)
 
 
 def test_apply_view_layers():
@@ -1544,7 +1545,7 @@ def test_apply_view_layers():
             },
         }
     }
-    run_graphql_test(query, correct, graph)
+    run_graphql_test(query, correct, graph, sort_output=True)
 
 
 def test_apply_view_layer():
@@ -1671,7 +1672,7 @@ def test_apply_view_layer():
             },
         }
     }
-    run_graphql_test(query, correct, graph)
+    run_graphql_test(query, correct, graph, sort_output=True)
 
 
 def test_apply_view_exclude_layer():
@@ -1861,7 +1862,7 @@ def test_apply_view_exclude_layer():
             },
         }
     }
-    run_graphql_test(query, correct, graph)
+    run_graphql_test(query, correct, graph, sort_output=True)
 
 
 def test_apply_view_exclude_layers():
@@ -2045,7 +2046,7 @@ def test_apply_view_exclude_layers():
             },
         }
     }
-    run_graphql_test(query, correct, graph)
+    run_graphql_test(query, correct, graph, sort_output=True)
 
 
 def test_apply_view_type_filter():
@@ -3214,7 +3215,7 @@ def test_valid_graph():
     correct = {
         "graph": {
             "applyViews": {
-                "edges": {"list": [{"id": ["6", "7"], "latestTime": {"timestamp": 5}}]}
+                "edges": {"list": [{"id": [6, 7], "latestTime": {"timestamp": 5}}]}
             }
         }
     }
diff --git a/python/tests/test_base_install/test_graphql/test_edge_sorting.py b/python/tests/test_base_install/test_graphql/test_edge_sorting.py
index a068a49069..c4358c92de 100644
--- a/python/tests/test_base_install/test_graphql/test_edge_sorting.py
+++ b/python/tests/test_base_install/test_graphql/test_edge_sorting.py
@@ -100,7 +100,7 @@ def test_graph_edge_no_sort(graph):
             }
         }
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 @pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
@@ -138,7 +138,7 @@ def test_graph_edge_sort_by_nothing(graph):
             }
         }
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 @pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
@@ -152,9 +152,6 @@ def test_graph_edge_sort_by_src(graph):
               src {
                 id
               }
-              dst {
-                id
-              }
             }
           }
         }
@@ -166,11 +163,11 @@ def test_graph_edge_sort_by_src(graph):
             "edges": {
                 "sorted": {
                     "list": [
-                        {"src": {"id": "a"}, "dst": {"id": "d"}},
-                        {"src": {"id": "a"}, "dst": {"id": "b"}},
-                        {"src": {"id": "b"}, "dst": {"id": "d"}},
-                        {"src": {"id": "b"}, "dst": {"id": "c"}},
-                        {"src": {"id": "c"}, "dst": {"id": "d"}},
+                        {"src": {"id": "a"}},
+                        {"src": {"id": "a"}},
+                        {"src": {"id": "b"}},
+                        {"src": {"id": "b"}},
+                        {"src": {"id": "c"}},
                     ]
                 }
             }
@@ -187,9 +184,6 @@ def test_graph_edge_sort_by_dst(graph):
         edges {
           sorted(sortBys: [{ dst: true }]) {
             list {
-              src {
-                id
-              }
               dst {
                 id
               }
@@ -204,11 +198,11 @@ def test_graph_edge_sort_by_dst(graph):
             "edges": {
                 "sorted": {
                     "list": [
-                        {"src": {"id": "a"}, "dst": {"id": "b"}},
-                        {"src": {"id": "b"}, "dst": {"id": "c"}},
-                        {"src": {"id": "a"}, "dst": {"id": "d"}},
-                        {"src": {"id": "b"}, "dst": {"id": "d"}},
-                        {"src": {"id": "c"}, "dst": {"id": "d"}},
+                        {"dst": {"id": "b"}},
+                        {"dst": {"id": "c"}},
+                        {"dst": {"id": "d"}},
+                        {"dst": {"id": "d"}},
+                        {"dst": {"id": "d"}},
                     ]
                 }
             }
@@ -450,33 +444,32 @@ def test_graph_edge_sort_by_eprop2(graph):
 @pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
 def test_graph_edge_sort_by_eprop3(graph):
     query = """
-    query {
-      graph(path: "g") {
-        edges {
-          sorted(sortBys: [{ property: "eprop3" }]) {
-            list {
-              src {
-                id
-              }
-              dst {
-                id
+          query {
+          graph(path: "g") {
+            edges {
+              sorted(sortBys: [{ property: "eprop3" }]) {
+                list {
+                  properties {
+                    get(key: "eprop3") {
+                      value
+                    }
+                  }
+                }
               }
             }
           }
         }
-      }
-    }
     """
     expected_output = {
         "graph": {
             "edges": {
                 "sorted": {
                     "list": [
-                        {"src": {"id": "b"}, "dst": {"id": "c"}},
-                        {"src": {"id": "a"}, "dst": {"id": "d"}},
-                        {"src": {"id": "b"}, "dst": {"id": "d"}},
-                        {"src": {"id": "c"}, "dst": {"id": "d"}},
-                        {"src": {"id": "a"}, "dst": {"id": "b"}},
+                        {"properties": {"get": {"value": "ayz123"}}},
+                        {"properties": {"get": {"value": "xyz123"}}},
+                        {"properties": {"get": {"value": "xyz123"}}},
+                        {"properties": {"get": {"value": "xyz123"}}},
+                        {"properties": {"get": {"value": "xyz1234"}}},
                     ]
                 }
             }
@@ -493,11 +486,10 @@ def test_graph_edge_sort_by_eprop4(graph):
         edges {
           sorted(sortBys: [{ property: "eprop4" }]) {
             list {
-              src {
-                id
-              }
-              dst {
-                id
+             properties {
+                get(key: "eprop4") {
+                  value
+                }
               }
             }
           }
@@ -510,11 +502,11 @@ def test_graph_edge_sort_by_eprop4(graph):
             "edges": {
                 "sorted": {
                     "list": [
-                        {"src": {"id": "b"}, "dst": {"id": "c"}},
-                        {"src": {"id": "c"}, "dst": {"id": "d"}},
-                        {"src": {"id": "a"}, "dst": {"id": "b"}},
-                        {"src": {"id": "a"}, "dst": {"id": "d"}},
-                        {"src": {"id": "b"}, "dst": {"id": "d"}},
+                        {"properties": {"get": None}},
+                        {"properties": {"get": {"value": False}}},
+                        {"properties": {"get": {"value": False}}},
+                        {"properties": {"get": {"value": True}}},
+                        {"properties": {"get": {"value": True}}},
                     ]
                 }
             }
diff --git a/python/tests/test_base_install/test_graphql/test_filters/test_edge_filter_gql.py b/python/tests/test_base_install/test_graphql/test_filters/test_edge_filter_gql.py
index ecf47baf31..0f0cdca85b 100644
--- a/python/tests/test_base_install/test_graphql/test_filters/test_edge_filter_gql.py
+++ b/python/tests/test_base_install/test_graphql/test_filters/test_edge_filter_gql.py
@@ -42,7 +42,7 @@ def test_filter_edges_with_str_ids_for_node_id_eq_gql(graph):
             }
         }
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 EVENT_GRAPH = init_graph2(Graph())
@@ -153,7 +153,7 @@ def test_edges_filter_window_is_active(graph):
             }
         }
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 @pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
diff --git a/python/tests/test_base_install/test_graphql/test_filters/test_graph_edges_property_filter.py b/python/tests/test_base_install/test_graphql/test_filters/test_graph_edges_property_filter.py
index dffbf30320..f3279b530d 100644
--- a/python/tests/test_base_install/test_graphql/test_filters/test_graph_edges_property_filter.py
+++ b/python/tests/test_base_install/test_graphql/test_filters/test_graph_edges_property_filter.py
@@ -198,7 +198,7 @@ def test_graph_edge_property_filter_less_than_or_equal(graph):
             }
         }
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 @pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
@@ -347,7 +347,7 @@ def test_graph_edge_property_filter_is_some(graph):
             }
         }
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 @pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
@@ -375,7 +375,7 @@ def test_graph_edge_property_filter_is_in(graph):
             }
         }
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 @pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
@@ -463,7 +463,7 @@ def test_graph_edge_property_filter_is_not_in_empty_list(graph):
             }
         }
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 @pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
@@ -518,7 +518,7 @@ def test_graph_edge_not_property_filter(graph):
             }
         }
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 @pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
@@ -550,7 +550,7 @@ def test_edges_property_filter_starts_with(graph):
             }
         }
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 @pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
@@ -582,7 +582,7 @@ def test_edges_property_filter_ends_with(graph):
             }
         }
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 EVENT_GRAPH = init_graph2(Graph())
@@ -612,7 +612,7 @@ def test_edges_selection(graph):
             }
         }
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 # The inner edges filter has no effect on the list of edges returned from selection filter
@@ -645,7 +645,7 @@ def test_edges_selection_edges_filter_paired(graph):
             }
         }
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 @pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
@@ -1070,4 +1070,4 @@ def test_edges_graph_filter_gql(graph):
             }
         }
     }
-    run_graphql_test(query, expected, graph)
+    run_graphql_test(query, expected, graph, sort_output=True)
diff --git a/python/tests/test_base_install/test_graphql/test_filters/test_graph_nodes_property_filter.py b/python/tests/test_base_install/test_graphql/test_filters/test_graph_nodes_property_filter.py
index a8f088b278..4160af99f5 100644
--- a/python/tests/test_base_install/test_graphql/test_filters/test_graph_nodes_property_filter.py
+++ b/python/tests/test_base_install/test_graphql/test_filters/test_graph_nodes_property_filter.py
@@ -74,7 +74,7 @@ def test_graph_node_property_filter_not_equal(graph):
     expected_output = {
         "graph": {"filterNodes": {"nodes": {"list": [{"name": "b"}, {"name": "d"}]}}}
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 @pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
@@ -169,7 +169,7 @@ def test_graph_node_property_filter_less_than_or_equal(graph):
             }
         }
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 @pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
@@ -243,7 +243,7 @@ def test_graph_node_property_filter_less_than(graph):
     expected_output = {
         "graph": {"filterNodes": {"nodes": {"list": [{"name": "b"}, {"name": "c"}]}}}
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 @pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
@@ -281,7 +281,7 @@ def test_graph_node_property_filter_is_none(graph):
     expected_output = {
         "graph": {"filterNodes": {"nodes": {"list": [{"name": "b"}, {"name": "d"}]}}}
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 @pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
@@ -319,7 +319,7 @@ def test_graph_node_property_filter_is_in(graph):
     expected_output = {
         "graph": {"filterNodes": {"nodes": {"list": [{"name": "b"}, {"name": "d"}]}}}
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 @pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
@@ -421,7 +421,7 @@ def test_node_property_filter_not_is_not_in_empty_list(graph):
             }
         }
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 @pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
@@ -472,7 +472,7 @@ def test_graph_node_not_property_filter(graph):
             }
         }
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 @pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
@@ -514,7 +514,7 @@ def test_graph_node_type_and_property_filter(graph):
             }
         }
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 @pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
@@ -542,7 +542,7 @@ def test_graph_nodes_property_filter_starts_with(graph):
             }
         }
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 @pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
diff --git a/python/tests/test_base_install/test_graphql/test_filters/test_neighbours_filter.py b/python/tests/test_base_install/test_graphql/test_filters/test_neighbours_filter.py
index 7079132e49..aa0804d114 100644
--- a/python/tests/test_base_install/test_graphql/test_filters/test_neighbours_filter.py
+++ b/python/tests/test_base_install/test_graphql/test_filters/test_neighbours_filter.py
@@ -218,7 +218,7 @@ def test_neighbours_found(graph):
             "node": {"filter": {"neighbours": {"list": [{"name": "b"}, {"name": "c"}]}}}
         }
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 @pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
@@ -321,11 +321,13 @@ def test_neighbours_neighbours_filtering(graph):
           graph(path: "g") {
             nodes(select: { property: { name: "p100", where: { gt: { i64: 30 } } } }) {
               list {
+                name
                 neighbours {
                   filter(expr: {
                      property: { name: "p2", where: { gt: { i64: 3 } } }
                   }) {
                     list {
+                      name
                       neighbours {
                         list {
                           name
@@ -344,28 +346,42 @@ def test_neighbours_neighbours_filtering(graph):
             "nodes": {
                 "list": [
                     {
+                        "name": "1",
                         "neighbours": {
                             "filter": {
                                 "list": [
-                                    {"neighbours": {"list": [{"name": "3"}]}},
-                                    {"neighbours": {"list": []}},
+                                    {
+                                        "name": "2",
+                                        "neighbours": {"list": [{"name": "3"}]},
+                                    },
+                                    {"name": "3", "neighbours": {"list": []}},
                                 ]
                             }
-                        }
+                        },
                     },
                     {
+                        "name": "3",
                         "neighbours": {
                             "filter": {
                                 "list": [
-                                    {"neighbours": {"list": [{"name": "3"}]}},
-                                    {"neighbours": {"list": [{"name": "3"}]}},
-                                    {"neighbours": {"list": [{"name": "3"}]}},
+                                    {
+                                        "name": "1",
+                                        "neighbours": {"list": [{"name": "3"}]},
+                                    },
+                                    {
+                                        "name": "2",
+                                        "neighbours": {"list": [{"name": "3"}]},
+                                    },
+                                    {
+                                        "name": "4",
+                                        "neighbours": {"list": [{"name": "3"}]},
+                                    },
                                 ]
                             }
-                        }
+                        },
                     },
                 ]
             }
         }
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
diff --git a/python/tests/test_base_install/test_graphql/test_filters/test_node_filter_gql.py b/python/tests/test_base_install/test_graphql/test_filters/test_node_filter_gql.py
index 3678f8dbfd..f9cd815905 100644
--- a/python/tests/test_base_install/test_graphql/test_filters/test_node_filter_gql.py
+++ b/python/tests/test_base_install/test_graphql/test_filters/test_node_filter_gql.py
@@ -140,7 +140,7 @@ def test_nodes_filter_windowed_is_active(graph):
             }
         }
     }
-    run_graphql_test(query, expected, graph)
+    run_graphql_test(query, expected, graph, sort_output=True)
 
 
 @pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
diff --git a/python/tests/test_base_install/test_graphql/test_filters/test_nodes_property_filter.py b/python/tests/test_base_install/test_graphql/test_filters/test_nodes_property_filter.py
index a26d27f4cf..72526d6ee2 100644
--- a/python/tests/test_base_install/test_graphql/test_filters/test_nodes_property_filter.py
+++ b/python/tests/test_base_install/test_graphql/test_filters/test_nodes_property_filter.py
@@ -34,12 +34,13 @@ def test_node_property_filter_equal2(graph):
             }
           ) {
             list {
-                neighbours {
-                  list {
-                    name
-                  }
+              name
+              neighbours {
+                list {
+                  name
                 }
-          }
+              }
+            }
           }
         }
       }
@@ -50,16 +51,16 @@ def test_node_property_filter_equal2(graph):
             "nodes": {
                 "filter": {
                     "list": [
-                        {"neighbours": {"list": []}},
-                        {"neighbours": {"list": []}},
-                        {"neighbours": {"list": []}},
-                        {"neighbours": {"list": [{"name": "a"}]}},
+                        {"name": "a", "neighbours": {"list": []}},
+                        {"name": "b", "neighbours": {"list": []}},
+                        {"name": "c", "neighbours": {"list": []}},
+                        {"name": "d", "neighbours": {"list": [{"name": "a"}]}},
                     ]
                 }
             }
         }
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 @pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
@@ -145,7 +146,7 @@ def test_node_property_filter_not_equal(graph):
     expected_output = {
         "graph": {"nodes": {"select": {"list": [{"name": "b"}, {"name": "d"}]}}}
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 @pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
@@ -265,7 +266,7 @@ def test_node_property_filter_less_than_or_equal(graph):
             "nodes": {"select": {"list": [{"name": "b"}, {"name": "c"}, {"name": "d"}]}}
         }
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 @pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
@@ -367,7 +368,7 @@ def test_node_property_filter_less_than(graph):
     expected_output = {
         "graph": {"nodes": {"select": {"list": [{"name": "b"}, {"name": "c"}]}}}
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 @pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
@@ -419,7 +420,7 @@ def test_node_property_filter_is_none(graph):
     expected_output = {
         "graph": {"nodes": {"select": {"list": [{"name": "b"}, {"name": "d"}]}}}
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 @pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
@@ -445,7 +446,7 @@ def test_node_property_filter_is_some(graph):
     expected_output = {
         "graph": {"nodes": {"select": {"list": [{"name": "a"}, {"name": "c"}]}}}
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 @pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
@@ -471,7 +472,7 @@ def test_node_property_filter_is_in(graph):
     expected_output = {
         "graph": {"nodes": {"select": {"list": [{"name": "b"}, {"name": "d"}]}}}
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 @pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
@@ -604,7 +605,7 @@ def test_node_property_filter_is_not_in_empty_list(graph):
             }
         }
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 @pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
@@ -682,7 +683,7 @@ def test_nodes_property_filter_starts_with(graph):
             }
         }
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 @pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
@@ -734,7 +735,7 @@ def test_nodes_property_filter_temporal_first_starts_with(graph):
             }
         }
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 @pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
@@ -823,7 +824,7 @@ def test_nodes_temporal_property_filter_agg(graph):
     expected_output = {
         "graph": {"filterNodes": {"nodes": {"list": [{"name": "2"}, {"name": "3"}]}}}
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 EVENT_GRAPH = create_test_graph(Graph())
@@ -864,6 +865,7 @@ def test_nodes_neighbours_selection_with_prop_filter(graph):
       graph(path: "g") {
         nodes(select: { property: { name: "p100", where: { gt: { i64: 30 } } } }) {
           list {
+            name
             neighbours {
               list {
                 name
@@ -878,17 +880,21 @@ def test_nodes_neighbours_selection_with_prop_filter(graph):
         "graph": {
             "nodes": {
                 "list": [
-                    {"neighbours": {"list": [{"name": "2"}, {"name": "3"}]}},
                     {
+                        "name": "1",
+                        "neighbours": {"list": [{"name": "2"}, {"name": "3"}]},
+                    },
+                    {
+                        "name": "3",
                         "neighbours": {
                             "list": [{"name": "1"}, {"name": "2"}, {"name": "4"}]
-                        }
+                        },
                     },
                 ]
             }
         }
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 @pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
diff --git a/python/tests/test_base_install/test_graphql/test_gql_graph_surface.py b/python/tests/test_base_install/test_graphql/test_gql_graph_surface.py
new file mode 100644
index 0000000000..3b9815cbc2
--- /dev/null
+++ b/python/tests/test_base_install/test_graphql/test_gql_graph_surface.py
@@ -0,0 +1,370 @@
+"""Tests for `Graph`-level fields that previously had no GraphQL coverage:
+
+- `countEdges`, `countNodes`, `countTemporalEdges`
+- `hasNode`, `hasEdge` (+ optional `layer:` arg on `hasEdge`)
+- `earliestEdgeTime`, `latestEdgeTime`
+- `uniqueLayers`
+- `sharedNeighbours`
+
+Each field is tested under a combination of base / window / layer views to
+exercise the composition plumbing, not just the field itself.
+
+`searchEdges` is left untested here — it's marked experimental in the schema
+and requires an index-creation path that these fixtures don't exercise.
+"""
+
+from utils import run_group_graphql_test
+from raphtory import Graph
+
+
+def create_graph() -> Graph:
+    graph = Graph()
+
+    # Nodes with a node_type so `typeFilter` paths could be reused
+    graph.add_node(10, "A", node_type="person")
+    graph.add_node(10, "B", node_type="person")
+    graph.add_node(15, "C", node_type="org")
+    graph.add_node(40, "D", node_type="org")
+
+    # Edges across two layers, including a self-loop and a reverse edge
+    graph.add_edge(10, "A", "B", properties={"weight": 1.0}, layer="layer1")
+    graph.add_edge(20, "A", "B", properties={"weight": 2.0}, layer="layer1")
+    graph.add_edge(30, "A", "B", properties={"weight": 3.0}, layer="layer2")
+    graph.add_edge(15, "A", "C", layer="layer1")
+    graph.add_edge(25, "A", "C", layer="layer2")
+    graph.add_edge(40, "C", "D", layer="layer1")
+    graph.add_edge(50, "B", "A", layer="layer2")
+    graph.add_edge(25, "A", "A", layer="layer1")  # self-loop
+
+    return graph
+
+
+def test_graph_counts():
+    """`countNodes`, `countEdges`, `countTemporalEdges` under base / window /
+    layer / layer+window views."""
+    graph = create_graph()
+    queries_and_expected = []
+
+    # base: 4 nodes, 5 unique edges (AB, AC, CD, BA, AA), 8 temporal edge events
+    query = """
+    {
+      graph(path: "g") {
+        countNodes
+        countEdges
+        countTemporalEdges
+      }
+    }
+    """
+    queries_and_expected.append(
+        (
+            query,
+            {
+                "graph": {
+                    "countNodes": 4,
+                    "countEdges": 5,
+                    "countTemporalEdges": 8,
+                }
+            },
+        )
+    )
+
+    # windowed [10, 30): drops t=30, 40, 50, keeps t=10..25.
+    # nodes visible: A, B, C (D not yet). edges: AB@layer1, AC@layer1, AC@layer2, AA@layer1 => 3 unique edges (AB, AC, AA).
+    # temporal edges in window: AB@10, AB@20, AC@15, AC@25, AA@25 => 5
+    query = """
+    {
+      graph(path: "g") {
+        window(start: 10, end: 30) {
+          countNodes
+          countEdges
+          countTemporalEdges
+        }
+      }
+    }
+    """
+    queries_and_expected.append(
+        (
+            query,
+            {
+                "graph": {
+                    "window": {
+                        "countNodes": 3,
+                        "countEdges": 3,
+                        "countTemporalEdges": 5,
+                    }
+                }
+            },
+        )
+    )
+
+    # layer(layer1) only: edges AB (2 updates), AC, CD, AA => 4 unique, 5 temporal
+    query = """
+    {
+      graph(path: "g") {
+        layer(name: "layer1") {
+          countNodes
+          countEdges
+          countTemporalEdges
+        }
+      }
+    }
+    """
+    queries_and_expected.append(
+        (
+            query,
+            {
+                "graph": {
+                    "layer": {
+                        "countNodes": 4,
+                        "countEdges": 4,
+                        "countTemporalEdges": 5,
+                    }
+                }
+            },
+        )
+    )
+
+    # layer(layer1) + window [10, 30): AB@10, AB@20, AC@15, AA@25 => 3 unique, 4 temporal
+    query = """
+    {
+      graph(path: "g") {
+        layer(name: "layer1") {
+          window(start: 10, end: 30) {
+            countNodes
+            countEdges
+            countTemporalEdges
+          }
+        }
+      }
+    }
+    """
+    queries_and_expected.append(
+        (
+            query,
+            {
+                "graph": {
+                    "layer": {
+                        "window": {
+                            "countNodes": 3,
+                            "countEdges": 3,
+                            "countTemporalEdges": 4,
+                        }
+                    }
+                }
+            },
+        )
+    )
+
+    run_group_graphql_test(queries_and_expected, graph)
+
+
+def test_has_node_and_has_edge():
+    """`hasNode` / `hasEdge` under base / window / layer views.
+
+    `hasEdge` also accepts an optional `layer:` arg.
+    """
+    graph = create_graph()
+    queries_and_expected = []
+
+    # base: all exist
+    query = """
+    {
+      graph(path: "g") {
+        hasA: hasNode(name: "A")
+        hasZ: hasNode(name: "Z")
+        edgeAB: hasEdge(src: "A", dst: "B")
+        edgeBA: hasEdge(src: "B", dst: "A")
+        edgeAD: hasEdge(src: "A", dst: "D")
+        edgeAB_layer1: hasEdge(src: "A", dst: "B", layer: "layer1")
+        edgeAB_layer2: hasEdge(src: "A", dst: "B", layer: "layer2")
+        edgeBA_layer1: hasEdge(src: "B", dst: "A", layer: "layer1")
+      }
+    }
+    """
+    queries_and_expected.append(
+        (
+            query,
+            {
+                "graph": {
+                    "hasA": True,
+                    "hasZ": False,
+                    "edgeAB": True,
+                    "edgeBA": True,
+                    "edgeAD": False,
+                    "edgeAB_layer1": True,
+                    "edgeAB_layer2": True,
+                    "edgeBA_layer1": False,  # B->A only exists on layer2
+                }
+            },
+        )
+    )
+
+    # windowed [10, 30): D not yet present, edge CD not yet either
+    query = """
+    {
+      graph(path: "g") {
+        window(start: 10, end: 30) {
+          hasD: hasNode(name: "D")
+          edgeCD: hasEdge(src: "C", dst: "D")
+          edgeAB: hasEdge(src: "A", dst: "B")
+        }
+      }
+    }
+    """
+    queries_and_expected.append(
+        (
+            query,
+            {
+                "graph": {
+                    "window": {
+                        "hasD": False,
+                        "edgeCD": False,
+                        "edgeAB": True,
+                    }
+                }
+            },
+        )
+    )
+
+    # layer(layer2): edge AB exists, BA exists on layer2, CD doesn't (layer1 only)
+    query = """
+    {
+      graph(path: "g") {
+        layer(name: "layer2") {
+          edgeAB: hasEdge(src: "A", dst: "B")
+          edgeBA: hasEdge(src: "B", dst: "A")
+          edgeCD: hasEdge(src: "C", dst: "D")
+        }
+      }
+    }
+    """
+    queries_and_expected.append(
+        (
+            query,
+            {
+                "graph": {
+                    "layer": {
+                        "edgeAB": True,
+                        "edgeBA": True,
+                        "edgeCD": False,
+                    }
+                }
+            },
+        )
+    )
+
+    run_group_graphql_test(queries_and_expected, graph)
+
+
+def test_edge_time_bounds_and_unique_layers():
+    """`earliestEdgeTime`, `latestEdgeTime`, `uniqueLayers` base + window + layer."""
+    graph = create_graph()
+    queries_and_expected = []
+
+    # base: edges from t=10 to t=50; layers layer1 + layer2
+    query = """
+    {
+      graph(path: "g") {
+        earliestEdgeTime { timestamp }
+        latestEdgeTime { timestamp }
+        uniqueLayers
+      }
+    }
+    """
+    queries_and_expected.append(
+        (
+            query,
+            {
+                "graph": {
+                    "earliestEdgeTime": {"timestamp": 10},
+                    "latestEdgeTime": {"timestamp": 50},
+                    "uniqueLayers": ["layer1", "layer2"],
+                }
+            },
+        )
+    )
+
+    # windowed: edges from t=15 to t=25 only
+    query = """
+    {
+      graph(path: "g") {
+        window(start: 15, end: 30) {
+          earliestEdgeTime { timestamp }
+          latestEdgeTime { timestamp }
+        }
+      }
+    }
+    """
+    queries_and_expected.append(
+        (
+            query,
+            {
+                "graph": {
+                    "window": {
+                        "earliestEdgeTime": {"timestamp": 15},
+                        "latestEdgeTime": {"timestamp": 25},
+                    }
+                }
+            },
+        )
+    )
+
+    # layer(layer2): edges at t=25, 30, 50
+    query = """
+    {
+      graph(path: "g") {
+        layer(name: "layer2") {
+          earliestEdgeTime { timestamp }
+          latestEdgeTime { timestamp }
+        }
+      }
+    }
+    """
+    queries_and_expected.append(
+        (
+            query,
+            {
+                "graph": {
+                    "layer": {
+                        "earliestEdgeTime": {"timestamp": 25},
+                        "latestEdgeTime": {"timestamp": 50},
+                    }
+                }
+            },
+        )
+    )
+
+    run_group_graphql_test(queries_and_expected, graph)
+
+
+def test_shared_neighbours():
+    """`sharedNeighbours` returns the intersection of neighbour sets."""
+    graph = create_graph()
+    queries_and_expected = []
+
+    # A's neighbours (undirected): {A (self-loop), B, C}
+    # B's neighbours: {A}  -> shared(A,B) = {A}
+    # C's neighbours: {A, D} -> shared(A,C) = {A}, shared(B,C) = {}
+    query = """
+    {
+      graph(path: "g") {
+        AB: sharedNeighbours(selectedNodes: ["A", "B"]) { name }
+        AC: sharedNeighbours(selectedNodes: ["A", "C"]) { name }
+        BC: sharedNeighbours(selectedNodes: ["B", "C"]) { name }
+      }
+    }
+    """
+    queries_and_expected.append(
+        (
+            query,
+            {
+                "graph": {
+                    "AB": [{"name": "A"}],
+                    "AC": [{"name": "A"}],
+                    "BC": [{"name": "A"}],
+                }
+            },
+        )
+    )
+
+    run_group_graphql_test(queries_and_expected, graph, sort_output=True)
diff --git a/python/tests/test_base_install/test_graphql/test_gql_graph_type.py b/python/tests/test_base_install/test_graphql/test_gql_graph_type.py
new file mode 100644
index 0000000000..a9f9463b60
--- /dev/null
+++ b/python/tests/test_base_install/test_graphql/test_gql_graph_type.py
@@ -0,0 +1,273 @@
+"""`graph(path:, graphType:)` accepts an optional `graphType` argument that
+re-interprets the stored graph at query time.
+
+- `EVENT` semantics: each update is a point-in-time event; windows only see
+  updates whose timestamps fall inside them.
+- `PERSISTENT` semantics: values carry forward until overwritten or deleted;
+  an edge added at t=1 is visible in a window starting at t=5.
+
+These tests confirm both forms of override work both ways, and that omitting
+the argument preserves the graph's native type.
+"""
+
+import json
+import tempfile
+
+from raphtory import Graph, PersistentGraph
+from raphtory.graphql import GraphServer
+
+from utils import PORT
+
+
+def _query(server, q: str) -> dict:
+    response = server.get_client().query(q)
+    return json.loads(response) if isinstance(response, str) else response
+
+
+def test_event_graph_default_uses_event_semantics():
+    """Without `graphType`, an event-stored graph keeps event semantics — a
+    window after the addition event sees no edge."""
+    work_dir = tempfile.mkdtemp()
+    g = Graph()
+    g.add_edge(1, "a", "b")
+    with GraphServer(work_dir).start(PORT) as server:
+        server.get_client().send_graph(path="g", graph=g)
+
+        result = _query(
+            server,
+            """
+            {
+              graph(path: "g") {
+                window(start: 5, end: 10) {
+                  hasEdge(src: "a", dst: "b")
+                }
+              }
+            }
+            """,
+        )
+        assert result["graph"]["window"]["hasEdge"] is False
+
+
+def test_event_graph_read_as_persistent_carries_value_forward():
+    """Reading an event graph through `graphType: PERSISTENT` makes the edge
+    visible in a window that starts after the addition event."""
+    work_dir = tempfile.mkdtemp()
+    g = Graph()
+    g.add_edge(1, "a", "b")
+    with GraphServer(work_dir).start(PORT) as server:
+        server.get_client().send_graph(path="g", graph=g)
+
+        result = _query(
+            server,
+            """
+            {
+              graph(path: "g", graphType: PERSISTENT) {
+                window(start: 5, end: 10) {
+                  hasEdge(src: "a", dst: "b")
+                }
+              }
+            }
+            """,
+        )
+        assert result["graph"]["window"]["hasEdge"] is True
+
+
+def test_persistent_graph_default_carries_value_forward():
+    """Without `graphType`, a persistent-stored graph keeps persistent
+    semantics — the edge is alive in a window after the add."""
+    work_dir = tempfile.mkdtemp()
+    g = PersistentGraph()
+    g.add_edge(1, "a", "b")
+    with GraphServer(work_dir).start(PORT) as server:
+        server.get_client().send_graph(path="g", graph=g)
+
+        result = _query(
+            server,
+            """
+            {
+              graph(path: "g") {
+                window(start: 5, end: 10) {
+                  hasEdge(src: "a", dst: "b")
+                }
+              }
+            }
+            """,
+        )
+        assert result["graph"]["window"]["hasEdge"] is True
+
+
+def test_persistent_graph_read_as_event_drops_carried_values():
+    """Reading a persistent graph through `graphType: EVENT` makes the edge
+    invisible in a window that starts after the addition event."""
+    work_dir = tempfile.mkdtemp()
+    g = PersistentGraph()
+    g.add_edge(1, "a", "b")
+    with GraphServer(work_dir).start(PORT) as server:
+        server.get_client().send_graph(path="g", graph=g)
+
+        result = _query(
+            server,
+            """
+            {
+              graph(path: "g", graphType: EVENT) {
+                window(start: 5, end: 10) {
+                  hasEdge(src: "a", dst: "b")
+                }
+              }
+            }
+            """,
+        )
+        assert result["graph"]["window"]["hasEdge"] is False
+
+
+def test_mutable_event_graph_default_uses_event_semantics():
+    """`updateGraph(path).graph` without `graphType` keeps event semantics."""
+    work_dir = tempfile.mkdtemp()
+    g = Graph()
+    g.add_edge(1, "a", "b")
+    with GraphServer(work_dir).start(PORT) as server:
+        server.get_client().send_graph(path="g", graph=g)
+
+        result = _query(
+            server,
+            """
+            {
+              updateGraph(path: "g") {
+                graph {
+                  window(start: 5, end: 10) { hasEdge(src: "a", dst: "b") }
+                }
+              }
+            }
+            """,
+        )
+        assert result["updateGraph"]["graph"]["window"]["hasEdge"] is False
+
+
+def test_mutable_event_graph_read_as_persistent_carries_value_forward():
+    """`updateGraph(path).graph(graphType: PERSISTENT)` re-interprets an
+    event-stored graph through persistent semantics."""
+    work_dir = tempfile.mkdtemp()
+    g = Graph()
+    g.add_edge(1, "a", "b")
+    with GraphServer(work_dir).start(PORT) as server:
+        server.get_client().send_graph(path="g", graph=g)
+
+        result = _query(
+            server,
+            """
+            {
+              updateGraph(path: "g") {
+                graph(graphType: PERSISTENT) {
+                  window(start: 5, end: 10) { hasEdge(src: "a", dst: "b") }
+                }
+              }
+            }
+            """,
+        )
+        assert result["updateGraph"]["graph"]["window"]["hasEdge"] is True
+
+
+def test_mutable_persistent_graph_default_carries_value_forward():
+    """`updateGraph(path).graph` on a persistent graph keeps persistent
+    semantics by default."""
+    work_dir = tempfile.mkdtemp()
+    g = PersistentGraph()
+    g.add_edge(1, "a", "b")
+    with GraphServer(work_dir).start(PORT) as server:
+        server.get_client().send_graph(path="g", graph=g)
+
+        result = _query(
+            server,
+            """
+            {
+              updateGraph(path: "g") {
+                graph {
+                  window(start: 5, end: 10) { hasEdge(src: "a", dst: "b") }
+                }
+              }
+            }
+            """,
+        )
+        assert result["updateGraph"]["graph"]["window"]["hasEdge"] is True
+
+
+def test_mutable_persistent_graph_read_as_event_drops_carried_values():
+    """`updateGraph(path).graph(graphType: EVENT)` re-interprets a
+    persistent graph through event semantics."""
+    work_dir = tempfile.mkdtemp()
+    g = PersistentGraph()
+    g.add_edge(1, "a", "b")
+    with GraphServer(work_dir).start(PORT) as server:
+        server.get_client().send_graph(path="g", graph=g)
+
+        result = _query(
+            server,
+            """
+            {
+              updateGraph(path: "g") {
+                graph(graphType: EVENT) {
+                  window(start: 5, end: 10) { hasEdge(src: "a", dst: "b") }
+                }
+              }
+            }
+            """,
+        )
+        assert result["updateGraph"]["graph"]["window"]["hasEdge"] is False
+
+
+def test_mutable_graph_reads_pending_mutations_through_override():
+    """Mutate via `updateGraph(path)`, then read back via the graph accessor
+    with a `graphType` override — both the existing data and the new edge
+    should be visible under the chosen semantics."""
+    work_dir = tempfile.mkdtemp()
+    g = Graph()
+    g.add_edge(1, "a", "b")
+    with GraphServer(work_dir).start(PORT) as server:
+        server.get_client().send_graph(path="g", graph=g)
+
+        result = _query(
+            server,
+            """
+            {
+              updateGraph(path: "g") {
+                addEdge(time: 2, src: "b", dst: "c") { success }
+                asPersistent: graph(graphType: PERSISTENT) {
+                  window(start: 5, end: 10) {
+                    abEdge: hasEdge(src: "a", dst: "b")
+                    bcEdge: hasEdge(src: "b", dst: "c")
+                  }
+                }
+              }
+            }
+            """,
+        )
+        win = result["updateGraph"]["asPersistent"]["window"]
+        assert win["abEdge"] is True
+        assert win["bcEdge"] is True
+
+
+def test_persistent_deletes_visible_via_persistent_view():
+    """A delete event in a persistent graph propagates: a window after the
+    deletion shows the edge as gone under persistent semantics."""
+    work_dir = tempfile.mkdtemp()
+    g = PersistentGraph()
+    g.add_edge(1, "a", "b")
+    g.delete_edge(5, "a", "b")
+    with GraphServer(work_dir).start(PORT) as server:
+        server.get_client().send_graph(path="g", graph=g)
+
+        result = _query(
+            server,
+            """
+            {
+              before: graph(path: "g") {
+                window(start: 2, end: 4) { hasEdge(src: "a", dst: "b") }
+              }
+              after: graph(path: "g") {
+                window(start: 6, end: 10) { hasEdge(src: "a", dst: "b") }
+              }
+            }
+            """,
+        )
+        assert result["before"]["window"]["hasEdge"] is True
+        assert result["after"]["window"]["hasEdge"] is False
diff --git a/python/tests/test_base_install/test_graphql/test_gql_misc_surface.py b/python/tests/test_base_install/test_graphql/test_gql_misc_surface.py
new file mode 100644
index 0000000000..8e31ccc630
--- /dev/null
+++ b/python/tests/test_base_install/test_graphql/test_gql_misc_surface.py
@@ -0,0 +1,361 @@
+"""Tests for smaller GraphQL surface fields that previously had no coverage:
+
+- `Nodes.ids`
+- `Edges.explode`, `Edges.explodeLayers`
+- `PathFromNode.ids`
+- `History.isEmpty`
+- `TemporalProperty.orderedDedupe`
+- `MetaGraph.nodeCount`, `MetaGraph.edgeCount`, `QueryRoot.graphMetadata`
+"""
+
+import json
+import tempfile
+
+from utils import PORT, run_group_graphql_test
+from raphtory import Graph
+from raphtory.graphql import GraphServer
+
+
+def create_graph() -> Graph:
+    graph = Graph()
+    graph.add_node(10, "A", node_type="person")
+    graph.add_node(10, "B", node_type="person")
+    graph.add_node(15, "C", node_type="org")
+    graph.add_node(40, "D", node_type="org")
+
+    graph.add_edge(10, "A", "B", properties={"weight": 1.0}, layer="layer1")
+    graph.add_edge(20, "A", "B", properties={"weight": 2.0}, layer="layer1")
+    graph.add_edge(30, "A", "B", properties={"weight": 3.0}, layer="layer2")
+    graph.add_edge(15, "A", "C", layer="layer1")
+    graph.add_edge(25, "A", "C", layer="layer2")
+    graph.add_edge(40, "C", "D", layer="layer1")
+    graph.add_edge(50, "B", "A", layer="layer2")
+    graph.add_edge(25, "A", "A", layer="layer1")
+
+    return graph
+
+
+def test_nodes_ids():
+    """`nodes.ids` on base / window / layer views. Order isn't guaranteed
+    by the resolver, so each result is compared as a set."""
+    graph = create_graph()
+
+    cases = [
+        # base: all 4 nodes present.
+        (
+            """{ graph(path: "g") { nodes { ids } } }""",
+            ("graph", "nodes"),
+            {"A", "B", "C", "D"},
+        ),
+        # window [10, 25): D (added at 40) excluded.
+        (
+            """{ graph(path: "g") { window(start: 10, end: 25) { nodes { ids } } } }""",
+            ("graph", "window", "nodes"),
+            {"A", "B", "C"},
+        ),
+        # layer(layer2): D only has a layer1 edge (C->D) but is still present
+        # because base-layer (non-layered) node events are always included in
+        # any layer view — D was added via `add_node(40, "D", ...)` with no
+        # layer arg.
+        (
+            """{ graph(path: "g") { layer(name: "layer2") { nodes { ids } } } }""",
+            ("graph", "layer", "nodes"),
+            {"A", "B", "C", "D"},
+        ),
+    ]
+
+    tmp = tempfile.mkdtemp()
+    with GraphServer(tmp, create_index=True).start(PORT) as server:
+        client = server.get_client()
+        client.send_graph(path="g", graph=graph)
+        for query, path, expected in cases:
+            response = client.query(query)
+            data = json.loads(response) if isinstance(response, str) else response
+            for key in path:
+                data = data[key]
+            assert set(data["ids"]) == expected, f"query: {query}"
+
+
+def test_edges_explode_and_explode_layers():
+    """`edges.explode` / `explodeLayers` — collection-level explosion."""
+    graph = create_graph()
+    queries_and_expected = []
+
+    # Restrict to layer(layer1) + window [10, 25) so the output stays small:
+    # edges in scope: A->B@10, A->B@20, A->C@15. 3 explode events.
+    # explodeLayers: one per (edge, layer) pair => 2 entries (A->B on layer1, A->C on layer1).
+    query = """
+    {
+      graph(path: "g") {
+        layer(name: "layer1") {
+          window(start: 10, end: 25) {
+            edges {
+              explode { list { src { name } dst { name } time { timestamp } layerName } }
+              explodeLayers { list { src { name } dst { name } layerName } }
+            }
+          }
+        }
+      }
+    }
+    """
+    expected = {
+        "graph": {
+            "layer": {
+                "window": {
+                    "edges": {
+                        "explode": {
+                            "list": [
+                                {
+                                    "src": {"name": "A"},
+                                    "dst": {"name": "B"},
+                                    "time": {"timestamp": 10},
+                                    "layerName": "layer1",
+                                },
+                                {
+                                    "src": {"name": "A"},
+                                    "dst": {"name": "B"},
+                                    "time": {"timestamp": 20},
+                                    "layerName": "layer1",
+                                },
+                                {
+                                    "src": {"name": "A"},
+                                    "dst": {"name": "C"},
+                                    "time": {"timestamp": 15},
+                                    "layerName": "layer1",
+                                },
+                            ]
+                        },
+                        "explodeLayers": {
+                            "list": [
+                                {
+                                    "src": {"name": "A"},
+                                    "dst": {"name": "B"},
+                                    "layerName": "layer1",
+                                },
+                                {
+                                    "src": {"name": "A"},
+                                    "dst": {"name": "C"},
+                                    "layerName": "layer1",
+                                },
+                            ]
+                        },
+                    }
+                }
+            }
+        }
+    }
+    queries_and_expected.append((query, expected))
+
+    run_group_graphql_test(queries_and_expected, graph, sort_output=True)
+
+
+def test_path_from_node_ids():
+    """`pathFromNode.ids` via `neighbours` / `inNeighbours` / `outNeighbours`."""
+    graph = create_graph()
+    queries_and_expected = []
+
+    # A's neighbours (undirected): B, C, A (self-loop).
+    # A's outNeighbours: B, C, A
+    # A's inNeighbours: A, B
+    query = """
+    {
+      graph(path: "g") {
+        node(name: "A") {
+          neighbours { ids }
+          outNeighbours { ids }
+          inNeighbours { ids }
+        }
+      }
+    }
+    """
+    queries_and_expected.append(
+        (
+            query,
+            {
+                "graph": {
+                    "node": {
+                        "neighbours": {"ids": ["A", "B", "C"]},
+                        "outNeighbours": {"ids": ["A", "B", "C"]},
+                        "inNeighbours": {"ids": ["A", "B"]},
+                    }
+                }
+            },
+        )
+    )
+
+    # layer(layer2) changes A's neighbourhood: A->B, A->C, B->A are the only
+    # layer2 edges touching A => neighbours={B, C}, outNeighbours={B, C}, inNeighbours={B}.
+    query = """
+    {
+      graph(path: "g") {
+        layer(name: "layer2") {
+          node(name: "A") {
+            neighbours { ids }
+            outNeighbours { ids }
+            inNeighbours { ids }
+          }
+        }
+      }
+    }
+    """
+    queries_and_expected.append(
+        (
+            query,
+            {
+                "graph": {
+                    "layer": {
+                        "node": {
+                            "neighbours": {"ids": ["B", "C"]},
+                            "outNeighbours": {"ids": ["B", "C"]},
+                            "inNeighbours": {"ids": ["B"]},
+                        }
+                    }
+                }
+            },
+        )
+    )
+
+    run_group_graphql_test(queries_and_expected, graph, sort_output=True)
+
+
+def test_history_is_empty():
+    """`history.isEmpty` is true on an empty window, false otherwise."""
+    graph = create_graph()
+    queries_and_expected = []
+
+    # A has history (created at t=10)
+    query = """{ graph(path: "g") { node(name: "A") { history { isEmpty } } } }"""
+    queries_and_expected.append(
+        (query, {"graph": {"node": {"history": {"isEmpty": False}}}})
+    )
+
+    # Windowing the node (not the graph) keeps the node reachable but empties
+    # its history => isEmpty = True.
+    query = """
+    {
+      graph(path: "g") {
+        node(name: "A") {
+          window(start: 0, end: 5) { history { isEmpty } }
+        }
+      }
+    }
+    """
+    queries_and_expected.append(
+        (
+            query,
+            {"graph": {"node": {"window": {"history": {"isEmpty": True}}}}},
+        )
+    )
+
+    # Same trick for an edge: pick a window with no A->B updates (the only
+    # A->B updates are at t=10, 20, 30).
+    query = """
+    {
+      graph(path: "g") {
+        edge(src: "A", dst: "B") {
+          window(start: 40, end: 45) { history { isEmpty } }
+        }
+      }
+    }
+    """
+    queries_and_expected.append(
+        (
+            query,
+            {"graph": {"edge": {"window": {"history": {"isEmpty": True}}}}},
+        )
+    )
+
+    # Edge A->B's full history is non-empty
+    query = """
+    {
+      graph(path: "g") {
+        edge(src: "A", dst: "B") { history { isEmpty } }
+      }
+    }
+    """
+    queries_and_expected.append(
+        (query, {"graph": {"edge": {"history": {"isEmpty": False}}}})
+    )
+
+    run_group_graphql_test(queries_and_expected, graph)
+
+
+def test_temporal_property_ordered_dedupe():
+    """`TemporalProperty.orderedDedupe` — collapses consecutive-equal updates."""
+    g = Graph()
+    # state timeline: a(1), a(2), b(3), a(4), a(5)
+    # latestTime=True  => keeps the latest timestamp of each run: (2,'a'), (3,'b'), (5,'a')
+    # latestTime=False => keeps the first timestamp of each run:   (1,'a'), (3,'b'), (4,'a')
+    g.add_node(1, "X", properties={"state": "a"})
+    g.add_node(2, "X", properties={"state": "a"})
+    g.add_node(3, "X", properties={"state": "b"})
+    g.add_node(4, "X", properties={"state": "a"})
+    g.add_node(5, "X", properties={"state": "a"})
+
+    queries_and_expected = []
+
+    query = """
+    {
+      graph(path: "g") {
+        node(name: "X") {
+          properties {
+            temporal {
+              get(key: "state") {
+                latest:  orderedDedupe(latestTime: true)  { time { timestamp } value }
+                first:   orderedDedupe(latestTime: false) { time { timestamp } value }
+              }
+            }
+          }
+        }
+      }
+    }
+    """
+    expected = {
+        "graph": {
+            "node": {
+                "properties": {
+                    "temporal": {
+                        "get": {
+                            "latest": [
+                                {"time": {"timestamp": 2}, "value": "a"},
+                                {"time": {"timestamp": 3}, "value": "b"},
+                                {"time": {"timestamp": 5}, "value": "a"},
+                            ],
+                            "first": [
+                                {"time": {"timestamp": 1}, "value": "a"},
+                                {"time": {"timestamp": 3}, "value": "b"},
+                                {"time": {"timestamp": 4}, "value": "a"},
+                            ],
+                        }
+                    }
+                }
+            }
+        }
+    }
+    queries_and_expected.append((query, expected))
+
+    run_group_graphql_test(queries_and_expected, g)
+
+
+def test_meta_graph_counts():
+    """`graphMetadata` → `MetaGraph.nodeCount` / `edgeCount` report persisted
+    counts for a stored graph without loading it."""
+    graph = create_graph()
+    queries_and_expected = []
+
+    query = """{ graphMetadata(path: "g") { nodeCount edgeCount name path } }"""
+    queries_and_expected.append(
+        (
+            query,
+            {
+                "graphMetadata": {
+                    "nodeCount": 4,
+                    "edgeCount": 5,
+                    "name": "g",
+                    "path": "g",
+                }
+            },
+        )
+    )
+
+    run_group_graphql_test(queries_and_expected, graph)
diff --git a/python/tests/test_base_install/test_graphql/test_gql_mutation_time_input.py b/python/tests/test_base_install/test_graphql/test_gql_mutation_time_input.py
new file mode 100644
index 0000000000..c3af13c853
--- /dev/null
+++ b/python/tests/test_base_install/test_graphql/test_gql_mutation_time_input.py
@@ -0,0 +1,303 @@
+"""Mutation arguments that take a time now accept the full `TimeInput` shape:
+
+- An `Int` (epoch milliseconds).
+- An RFC3339 / ISO-8601 datetime string.
+- An `{timestamp, eventId}` object.
+
+These tests verify each form on every mutation surface that takes a time, and
+confirm the resulting graph state is identical regardless of which input form
+was used.
+"""
+
+import json
+import tempfile
+
+from raphtory import Graph
+from raphtory.graphql import GraphServer
+
+from utils import PORT
+
+
+def _query(server, q: str) -> dict:
+    response = server.get_client().query(q)
+    return json.loads(response) if isinstance(response, str) else response
+
+
+def test_add_node_accepts_int_string_and_object_time():
+    """`addNode` accepts every `TimeInput` shape — Int, RFC3339 string, and
+    `{timestamp, eventId}` object. Each insertion lands at its expected
+    timestamp and is queryable afterwards."""
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir, create_index=True).start(PORT) as server:
+        client = server.get_client()
+        client.new_graph("g", "EVENT")
+
+        # Three forms, three different nodes.
+        client.query("""
+            {
+              updateGraph(path: "g") {
+                int_form: addNode(time: 100, name: "intNode") { success }
+                str_form: addNode(time: "1970-01-01T00:00:00.200Z", name: "strNode") { success }
+                obj_form: addNode(time: {timestamp: 300, eventId: 0}, name: "objNode") { success }
+              }
+            }
+            """)
+
+        # Verify each landed at the expected timestamp.
+        result = _query(
+            server,
+            """
+            {
+              graph(path: "g") {
+                intNode: node(name: "intNode") { earliestTime { timestamp } }
+                strNode: node(name: "strNode") { earliestTime { timestamp } }
+                objNode: node(name: "objNode") { earliestTime { timestamp } }
+              }
+            }
+            """,
+        )
+        assert result["graph"]["intNode"]["earliestTime"]["timestamp"] == 100
+        assert result["graph"]["strNode"]["earliestTime"]["timestamp"] == 200
+        assert result["graph"]["objNode"]["earliestTime"]["timestamp"] == 300
+
+
+def test_add_edge_and_delete_edge_accept_time_input_shapes():
+    """`addEdge` / `deleteEdge` accept the same forms; verify on a persistent
+    graph so the deletion is visible via `isValid`."""
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir, create_index=True).start(PORT) as server:
+        client = server.get_client()
+        client.new_graph("g", "PERSISTENT")
+
+        client.query("""
+            {
+              updateGraph(path: "g") {
+                int_add: addEdge(time: 10, src: "a", dst: "b") { success }
+                str_add: addEdge(time: "1970-01-01T00:00:00.020Z", src: "a", dst: "b") { success }
+                obj_del: deleteEdge(time: {timestamp: 30, eventId: 0}, src: "a", dst: "b") { success }
+              }
+            }
+            """)
+
+        result = _query(
+            server,
+            """
+            {
+              graph(path: "g") {
+                edge(src: "a", dst: "b") {
+                  earliestTime { timestamp }
+                  latestTime { timestamp }
+                  isValid
+                }
+              }
+            }
+            """,
+        )
+        edge = result["graph"]["edge"]
+        assert edge["earliestTime"]["timestamp"] == 10
+        # On a persistent graph, the deletion sets the latest valid time.
+        assert edge["latestTime"]["timestamp"] == 30
+        # Edge was deleted at t=30 with no later re-addition, so it's invalid now.
+        assert edge["isValid"] is False
+
+
+def test_add_properties_accepts_time_input_shapes():
+    """`addProperties` (graph-level temporal properties) accepts Int, string,
+    and object."""
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir, create_index=True).start(PORT) as server:
+        client = server.get_client()
+        client.new_graph("g", "EVENT")
+
+        client.query("""
+            {
+              updateGraph(path: "g") {
+                p1: addProperties(t: 100, properties: [{key: "score", value: {i64: 1}}])
+                p2: addProperties(t: "1970-01-01T00:00:00.200Z", properties: [{key: "score", value: {i64: 2}}])
+                p3: addProperties(t: {timestamp: 300, eventId: 0}, properties: [{key: "score", value: {i64: 3}}])
+              }
+            }
+            """)
+
+        result = _query(
+            server,
+            """
+            {
+              graph(path: "g") {
+                properties {
+                  temporal {
+                    get(key: "score") {
+                      history { list { timestamp } }
+                      values
+                    }
+                  }
+                }
+              }
+            }
+            """,
+        )
+        score = result["graph"]["properties"]["temporal"]["get"]
+        timestamps = [h["timestamp"] for h in score["history"]["list"]]
+        # History is returned in temporal order; not sorting on purpose so a
+        # regression that returns events out of order would fail this test.
+        assert timestamps == [100, 200, 300]
+        assert score["values"] == [1, 2, 3]
+
+
+def test_temporal_property_input_accepts_time_input_in_batch():
+    """Inside `addNodes` / `addEdges`, the `time` field on each per-update
+    `TemporalPropertyInput` accepts every `TimeInput` shape."""
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir, create_index=True).start(PORT) as server:
+        client = server.get_client()
+        client.new_graph("g", "EVENT")
+
+        client.query("""
+            {
+              updateGraph(path: "g") {
+                addNodes(nodes: [
+                  {
+                    name: "n",
+                    updates: [
+                      { time: 10,                              properties: [{key: "v", value: {i64: 1}}] },
+                      { time: "1970-01-01T00:00:00.020Z",      properties: [{key: "v", value: {i64: 2}}] },
+                      { time: {timestamp: 30, eventId: 0},     properties: [{key: "v", value: {i64: 3}}] }
+                    ]
+                  }
+                ])
+              }
+            }
+            """)
+
+        result = _query(
+            server,
+            """
+            {
+              graph(path: "g") {
+                node(name: "n") {
+                  properties { temporal { get(key: "v") {
+                    history { list { timestamp } }
+                    values
+                  } } }
+                }
+              }
+            }
+            """,
+        )
+        v = result["graph"]["node"]["properties"]["temporal"]["get"]
+        timestamps = [h["timestamp"] for h in v["history"]["list"]]
+        assert timestamps == [10, 20, 30]
+        assert v["values"] == [1, 2, 3]
+
+
+def test_add_edges_batch_accepts_time_input_shapes():
+    """`addEdges` is the batch counterpart of `addNodes`. Each per-update
+    `time` field on its `TemporalPropertyInput` entries accepts every
+    `TimeInput` shape — Int, RFC3339 string, and `{timestamp, eventId}` object."""
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir, create_index=True).start(PORT) as server:
+        client = server.get_client()
+        client.new_graph("g", "EVENT")
+
+        client.query("""
+            {
+              updateGraph(path: "g") {
+                addEdges(edges: [
+                  {
+                    src: "a", dst: "b",
+                    updates: [
+                      { time: 10,                              properties: [{key: "w", value: {i64: 1}}] },
+                      { time: "1970-01-01T00:00:00.020Z",      properties: [{key: "w", value: {i64: 2}}] },
+                      { time: {timestamp: 30, eventId: 0},     properties: [{key: "w", value: {i64: 3}}] }
+                    ]
+                  }
+                ])
+              }
+            }
+            """)
+
+        result = _query(
+            server,
+            """
+            {
+              graph(path: "g") {
+                edge(src: "a", dst: "b") {
+                  properties { temporal { get(key: "w") {
+                    history { list { timestamp } }
+                    values
+                  } } }
+                }
+              }
+            }
+            """,
+        )
+        w = result["graph"]["edge"]["properties"]["temporal"]["get"]
+        timestamps = [h["timestamp"] for h in w["history"]["list"]]
+        assert timestamps == [10, 20, 30]
+        assert w["values"] == [1, 2, 3]
+
+
+def test_mutable_node_and_edge_add_updates_accept_time_input():
+    """`MutableNode.addUpdates` and `MutableEdge.addUpdates` / `delete` accept
+    every `TimeInput` shape via the `node()` / `edge()` lookups."""
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir, create_index=True).start(PORT) as server:
+        client = server.get_client()
+        client.new_graph("g", "PERSISTENT")
+
+        # Seed the node and edge so we can look them up below.
+        client.query("""
+            {
+              updateGraph(path: "g") {
+                addNode(time: 0, name: "n") { success }
+                addEdge(time: 0, src: "a", dst: "b") { success }
+              }
+            }
+            """)
+
+        client.query("""
+            {
+              updateGraph(path: "g") {
+                node(name: "n") {
+                  i: addUpdates(time: 100,                          properties: [{key: "v", value: {i64: 1}}])
+                  s: addUpdates(time: "1970-01-01T00:00:00.200Z",   properties: [{key: "v", value: {i64: 2}}])
+                  o: addUpdates(time: {timestamp: 300, eventId: 0}, properties: [{key: "v", value: {i64: 3}}])
+                }
+                edge(src: "a", dst: "b") {
+                  i: addUpdates(time: 10,                           properties: [{key: "w", value: {i64: 1}}])
+                  s: addUpdates(time: "1970-01-01T00:00:00.020Z",   properties: [{key: "w", value: {i64: 2}}])
+                  d: delete(time: {timestamp: 30, eventId: 0})
+                }
+              }
+            }
+            """)
+
+        result = _query(
+            server,
+            """
+            {
+              graph(path: "g") {
+                node(name: "n") {
+                  properties { temporal { get(key: "v") { values } } }
+                }
+                edge(src: "a", dst: "b") {
+                  properties { temporal { get(key: "w") { values } } }
+                  isValid
+                }
+              }
+            }
+            """,
+        )
+        # Values come back in temporal order — assert the sequence as-is so
+        # an out-of-order regression would fail.
+        assert result["graph"]["node"]["properties"]["temporal"]["get"]["values"] == [
+            1,
+            2,
+            3,
+        ]
+        assert result["graph"]["edge"]["properties"]["temporal"]["get"]["values"] == [
+            1,
+            2,
+        ]
+        # delete at t=30 with no later re-add → edge is invalid at the latest time.
+        assert result["graph"]["edge"]["isValid"] is False
diff --git a/python/tests/test_base_install/test_graphql/test_gql_node_edge_surface.py b/python/tests/test_base_install/test_graphql/test_gql_node_edge_surface.py
new file mode 100644
index 0000000000..eecf8b1590
--- /dev/null
+++ b/python/tests/test_base_install/test_graphql/test_gql_node_edge_surface.py
@@ -0,0 +1,588 @@
+"""Tests for `Node` and `Edge` fields that previously had no GraphQL coverage.
+
+Node fields covered:
+- `firstUpdate`, `lastUpdate`
+- `edgeHistoryCount`
+- `inDegree`, `outDegree`
+- `inEdges`, `outEdges`
+
+Edge fields covered:
+- `firstUpdate`, `lastUpdate`
+- `layerNames`
+- `layerName` (with error case)
+- `explode`, `explodeLayers`
+- `isValid`, `isSelfLoop`
+- `nbr` on an exploded edge
+
+All tested under base + window + layer composition where applicable.
+"""
+
+from utils import run_group_graphql_test, run_graphql_error_test_contains
+from raphtory import Graph
+
+
+def create_graph() -> Graph:
+    graph = Graph()
+
+    graph.add_node(10, "A", node_type="person")
+    graph.add_node(10, "B", node_type="person")
+    graph.add_node(15, "C", node_type="org")
+    graph.add_node(40, "D", node_type="org")
+
+    graph.add_edge(10, "A", "B", properties={"weight": 1.0}, layer="layer1")
+    graph.add_edge(20, "A", "B", properties={"weight": 2.0}, layer="layer1")
+    graph.add_edge(30, "A", "B", properties={"weight": 3.0}, layer="layer2")
+    graph.add_edge(15, "A", "C", layer="layer1")
+    graph.add_edge(25, "A", "C", layer="layer2")
+    graph.add_edge(40, "C", "D", layer="layer1")
+    graph.add_edge(50, "B", "A", layer="layer2")
+    graph.add_edge(25, "A", "A", layer="layer1")  # self-loop
+
+    return graph
+
+
+def test_node_update_times_and_edge_history_count():
+    """`firstUpdate`, `lastUpdate`, `edgeHistoryCount` under base / window / layer."""
+    graph = create_graph()
+    queries_and_expected = []
+
+    # Base: A has events from t=10 (add_node + A->B) to t=50 (B->A).
+    # Edge events touching A: A->B @10, @20, @30; A->C @15, @25; A->A @25; B->A @50 => 7.
+    query = """
+    {
+      graph(path: "g") {
+        node(name: "A") {
+          firstUpdate { timestamp }
+          lastUpdate { timestamp }
+          edgeHistoryCount
+        }
+      }
+    }
+    """
+    queries_and_expected.append(
+        (
+            query,
+            {
+                "graph": {
+                    "node": {
+                        "firstUpdate": {"timestamp": 10},
+                        "lastUpdate": {"timestamp": 50},
+                        "edgeHistoryCount": 7,
+                    }
+                }
+            },
+        )
+    )
+
+    # Windowed [15, 40): first event for A is at 15 (A->C), last is at 30 (A->B).
+    # Events touching A in window: A->B@20, A->B@30, A->C@15, A->C@25, A->A@25 => 5.
+    query = """
+    {
+      graph(path: "g") {
+        window(start: 15, end: 40) {
+          node(name: "A") {
+            firstUpdate { timestamp }
+            lastUpdate { timestamp }
+            edgeHistoryCount
+          }
+        }
+      }
+    }
+    """
+    queries_and_expected.append(
+        (
+            query,
+            {
+                "graph": {
+                    "window": {
+                        "node": {
+                            "firstUpdate": {"timestamp": 15},
+                            "lastUpdate": {"timestamp": 30},
+                            "edgeHistoryCount": 5,
+                        }
+                    }
+                }
+            },
+        )
+    )
+
+    # Windowed [16, 40): firstUpdate must reflect the first event *inside* the
+    # window (t=20, A->B), not the window start (t=16). The previous case had
+    # an event at exactly the window start which would mask a bug returning
+    # the window start instead of the first real update.
+    # Events touching A in window: A->B@20, A->C@25, A->A@25, A->B@30 => 4.
+    query = """
+    {
+      graph(path: "g") {
+        window(start: 16, end: 40) {
+          node(name: "A") {
+            firstUpdate { timestamp }
+            lastUpdate { timestamp }
+            edgeHistoryCount
+          }
+        }
+      }
+    }
+    """
+    queries_and_expected.append(
+        (
+            query,
+            {
+                "graph": {
+                    "window": {
+                        "node": {
+                            "firstUpdate": {"timestamp": 20},
+                            "lastUpdate": {"timestamp": 30},
+                            "edgeHistoryCount": 4,
+                        }
+                    }
+                }
+            },
+        )
+    )
+
+    # layer(layer2) on A: node events (add_node @ t=10) aren't layer-scoped so
+    # firstUpdate still sees t=10. Edge events on layer2 touching A are at 25,
+    # 30, 50 => lastUpdate=50, edgeHistoryCount=3.
+    query = """
+    {
+      graph(path: "g") {
+        layer(name: "layer2") {
+          node(name: "A") {
+            firstUpdate { timestamp }
+            lastUpdate { timestamp }
+            edgeHistoryCount
+          }
+        }
+      }
+    }
+    """
+    queries_and_expected.append(
+        (
+            query,
+            {
+                "graph": {
+                    "layer": {
+                        "node": {
+                            "firstUpdate": {"timestamp": 10},
+                            "lastUpdate": {"timestamp": 50},
+                            "edgeHistoryCount": 3,
+                        }
+                    }
+                }
+            },
+        )
+    )
+
+    run_group_graphql_test(queries_and_expected, graph)
+
+
+def test_node_directed_degrees_and_edges():
+    """`inDegree`, `outDegree`, `inEdges`, `outEdges` under base / window / layer."""
+    graph = create_graph()
+    queries_and_expected = []
+
+    # Base on A:
+    # out-edges: A->B, A->C, A->A   => outDegree=3
+    # in-edges:  A->A, B->A         => inDegree=2
+    query = """
+    {
+      graph(path: "g") {
+        node(name: "A") {
+          inDegree
+          outDegree
+          inEdges  { list { src { name } dst { name } } }
+          outEdges { list { src { name } dst { name } } }
+        }
+      }
+    }
+    """
+    queries_and_expected.append(
+        (
+            query,
+            {
+                "graph": {
+                    "node": {
+                        "inDegree": 2,
+                        "outDegree": 3,
+                        "inEdges": {
+                            "list": [
+                                {"src": {"name": "A"}, "dst": {"name": "A"}},
+                                {"src": {"name": "B"}, "dst": {"name": "A"}},
+                            ]
+                        },
+                        "outEdges": {
+                            "list": [
+                                {"src": {"name": "A"}, "dst": {"name": "B"}},
+                                {"src": {"name": "A"}, "dst": {"name": "C"}},
+                                {"src": {"name": "A"}, "dst": {"name": "A"}},
+                            ]
+                        },
+                    }
+                }
+            },
+        )
+    )
+
+    # layer(layer2): only A->B@30, A->C@25, B->A@50 touch A.
+    #   outEdges(A): A->B, A->C    (no A->A since self-loop is layer1)
+    #   inEdges(A):  B->A
+    query = """
+    {
+      graph(path: "g") {
+        layer(name: "layer2") {
+          node(name: "A") {
+            inDegree
+            outDegree
+            inEdges  { list { src { name } dst { name } } }
+            outEdges { list { src { name } dst { name } } }
+          }
+        }
+      }
+    }
+    """
+    queries_and_expected.append(
+        (
+            query,
+            {
+                "graph": {
+                    "layer": {
+                        "node": {
+                            "inDegree": 1,
+                            "outDegree": 2,
+                            "inEdges": {
+                                "list": [
+                                    {"src": {"name": "B"}, "dst": {"name": "A"}},
+                                ]
+                            },
+                            "outEdges": {
+                                "list": [
+                                    {"src": {"name": "A"}, "dst": {"name": "B"}},
+                                    {"src": {"name": "A"}, "dst": {"name": "C"}},
+                                ]
+                            },
+                        }
+                    }
+                }
+            },
+        )
+    )
+
+    # windowed [10, 30): A->A@25 + A->B@10, A->B@20 + A->C@15 => A has 3 out-edges (to A, B, C), 1 in-edge (A->A)
+    query = """
+    {
+      graph(path: "g") {
+        window(start: 10, end: 30) {
+          node(name: "A") {
+            inDegree
+            outDegree
+          }
+        }
+      }
+    }
+    """
+    queries_and_expected.append(
+        (
+            query,
+            {
+                "graph": {
+                    "window": {
+                        "node": {
+                            "inDegree": 1,
+                            "outDegree": 3,
+                        }
+                    }
+                }
+            },
+        )
+    )
+
+    run_group_graphql_test(queries_and_expected, graph, sort_output=True)
+
+
+def test_edge_update_times():
+    """`firstUpdate` / `lastUpdate` on edges under base / window / layer."""
+    graph = create_graph()
+    queries_and_expected = []
+
+    # A->B: base updates at 10, 20, 30. first=10, last=30.
+    query = """
+    {
+      graph(path: "g") {
+        edge(src: "A", dst: "B") {
+          firstUpdate { timestamp }
+          lastUpdate { timestamp }
+        }
+      }
+    }
+    """
+    queries_and_expected.append(
+        (
+            query,
+            {
+                "graph": {
+                    "edge": {
+                        "firstUpdate": {"timestamp": 10},
+                        "lastUpdate": {"timestamp": 30},
+                    }
+                }
+            },
+        )
+    )
+
+    # layer(layer1) on A->B: updates at 10 and 20 only.
+    query = """
+    {
+      graph(path: "g") {
+        layer(name: "layer1") {
+          edge(src: "A", dst: "B") {
+            firstUpdate { timestamp }
+            lastUpdate { timestamp }
+          }
+        }
+      }
+    }
+    """
+    queries_and_expected.append(
+        (
+            query,
+            {
+                "graph": {
+                    "layer": {
+                        "edge": {
+                            "firstUpdate": {"timestamp": 10},
+                            "lastUpdate": {"timestamp": 20},
+                        }
+                    }
+                }
+            },
+        )
+    )
+
+    # window [15, 25) on A->B: only update at 20.
+    query = """
+    {
+      graph(path: "g") {
+        window(start: 15, end: 25) {
+          edge(src: "A", dst: "B") {
+            firstUpdate { timestamp }
+            lastUpdate { timestamp }
+          }
+        }
+      }
+    }
+    """
+    queries_and_expected.append(
+        (
+            query,
+            {
+                "graph": {
+                    "window": {
+                        "edge": {
+                            "firstUpdate": {"timestamp": 20},
+                            "lastUpdate": {"timestamp": 20},
+                        }
+                    }
+                }
+            },
+        )
+    )
+
+    run_group_graphql_test(queries_and_expected, graph)
+
+
+def test_edge_layers_and_explode():
+    """`layerNames`, `layerName`, `explode`, `explodeLayers`, `isSelfLoop`, `isValid`."""
+    graph = create_graph()
+    queries_and_expected = []
+
+    # A->B spans layer1 + layer2
+    query = """
+    {
+      graph(path: "g") {
+        edge(src: "A", dst: "B") {
+          layerNames
+          isSelfLoop
+          isValid
+          explode { list { src { name } dst { name } time { timestamp } layerName } }
+          explodeLayers { list { layerName } }
+        }
+      }
+    }
+    """
+    queries_and_expected.append(
+        (
+            query,
+            {
+                "graph": {
+                    "edge": {
+                        "layerNames": ["layer1", "layer2"],
+                        "isSelfLoop": False,
+                        "isValid": True,
+                        "explode": {
+                            "list": [
+                                {
+                                    "src": {"name": "A"},
+                                    "dst": {"name": "B"},
+                                    "time": {"timestamp": 10},
+                                    "layerName": "layer1",
+                                },
+                                {
+                                    "src": {"name": "A"},
+                                    "dst": {"name": "B"},
+                                    "time": {"timestamp": 20},
+                                    "layerName": "layer1",
+                                },
+                                {
+                                    "src": {"name": "A"},
+                                    "dst": {"name": "B"},
+                                    "time": {"timestamp": 30},
+                                    "layerName": "layer2",
+                                },
+                            ]
+                        },
+                        "explodeLayers": {
+                            "list": [
+                                {"layerName": "layer1"},
+                                {"layerName": "layer2"},
+                            ]
+                        },
+                    }
+                }
+            },
+        )
+    )
+
+    # A->A self-loop (layer1 only)
+    query = """
+    {
+      graph(path: "g") {
+        edge(src: "A", dst: "A") {
+          isSelfLoop
+          layerNames
+        }
+      }
+    }
+    """
+    queries_and_expected.append(
+        (
+            query,
+            {
+                "graph": {
+                    "edge": {
+                        "isSelfLoop": True,
+                        "layerNames": ["layer1"],
+                    }
+                }
+            },
+        )
+    )
+
+    # `layerName` only works on edges that have been exploded (either fully or
+    # per-layer). Verified via explodeLayers on a multi-layer edge.
+    query = """
+    {
+      graph(path: "g") {
+        edge(src: "A", dst: "B") {
+          explodeLayers { list { layerName layerNames } }
+        }
+      }
+    }
+    """
+    queries_and_expected.append(
+        (
+            query,
+            {
+                "graph": {
+                    "edge": {
+                        "explodeLayers": {
+                            "list": [
+                                {"layerName": "layer1", "layerNames": ["layer1"]},
+                                {"layerName": "layer2", "layerNames": ["layer2"]},
+                            ]
+                        }
+                    }
+                }
+            },
+        )
+    )
+
+    run_group_graphql_test(queries_and_expected, graph)
+
+
+def test_edge_layer_name_errors_on_non_exploded_edge():
+    """`layerName` errors on any edge that hasn't been exploded — the
+    single-layer form is only available after `.explode()` or
+    `.explodeLayers()`."""
+    query = """
+    {
+      graph(path: "g") {
+        edge(src: "A", dst: "B") {
+          layerName
+        }
+      }
+    }
+    """
+    run_graphql_error_test_contains(
+        query, ["layer_name function is only available", "exploded"], create_graph()
+    )
+
+
+def test_edge_nbr_on_exploded_edge():
+    """`nbr` on the exploded form of an out-edge returns `dst`."""
+    graph = create_graph()
+    queries_and_expected = []
+
+    # Explode A->B and ask for `nbr` on each: each should be B (the other end).
+    query = """
+    {
+      graph(path: "g") {
+        node(name: "A") {
+          outEdges {
+            list {
+              explode { list { nbr { name } } }
+            }
+          }
+        }
+      }
+    }
+    """
+    # A has three out-edges (A->A, A->B, A->C). nbr of each exploded event is
+    # the "other" node — for A->A that's A (both ends), for A->B it's B, etc.
+    # A->A: 1 exploded event  -> [A]
+    # A->B: 3 exploded events -> [B, B, B]
+    # A->C: 2 exploded events -> [C, C]
+    expected = {
+        "graph": {
+            "node": {
+                "outEdges": {
+                    "list": [
+                        {
+                            "explode": {
+                                "list": [{"nbr": {"name": "A"}}],
+                            }
+                        },
+                        {
+                            "explode": {
+                                "list": [
+                                    {"nbr": {"name": "B"}},
+                                    {"nbr": {"name": "B"}},
+                                    {"nbr": {"name": "B"}},
+                                ],
+                            }
+                        },
+                        {
+                            "explode": {
+                                "list": [
+                                    {"nbr": {"name": "C"}},
+                                    {"nbr": {"name": "C"}},
+                                ],
+                            }
+                        },
+                    ]
+                }
+            }
+        }
+    }
+    queries_and_expected.append((query, expected))
+    run_group_graphql_test(queries_and_expected, graph, sort_output=True)
diff --git a/python/tests/test_base_install/test_graphql/test_gql_node_id.py b/python/tests/test_base_install/test_graphql/test_gql_node_id.py
new file mode 100644
index 0000000000..626662d6ff
--- /dev/null
+++ b/python/tests/test_base_install/test_graphql/test_gql_node_id.py
@@ -0,0 +1,318 @@
+"""Node-id arguments now accept the full `NodeId` shape:
+
+- A `String` (e.g. `"alice"`).
+- A non-negative `Int` (e.g. `42`).
+
+These tests exercise both forms across the major lookup, mutation, and
+view-transform surfaces, and confirm a graph indexed by integers can be
+queried and mutated through the GraphQL server.
+"""
+
+import json
+import tempfile
+
+from raphtory import Graph
+from raphtory.graphql import GraphServer
+
+from utils import PORT
+
+
+def _query(server, q: str) -> dict:
+    response = server.get_client().query(q)
+    return json.loads(response) if isinstance(response, str) else response
+
+
+def test_addnode_and_node_lookup_with_integer_ids():
+    """A graph with integer node ids can be added and queried via the
+    GraphQL server. Raphtory enforces a single id type per graph, so this
+    test uses integers throughout."""
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir, create_index=True).start(PORT) as server:
+        client = server.get_client()
+        client.new_graph("g", "EVENT")
+
+        client.query("""
+            {
+              updateGraph(path: "g") {
+                a: addNode(time: 1, name: 1) { success }
+                b: addNode(time: 2, name: 2) { success }
+                c: addNode(time: 3, name: 42) { success }
+              }
+            }
+            """)
+
+        result = _query(
+            server,
+            """
+            {
+              graph(path: "g") {
+                hasInt:    hasNode(name: 1)
+                hasOther:  hasNode(name: 42)
+                hasMissingInt: hasNode(name: 999)
+                int_node:  node(name: 1)  { earliestTime { timestamp } }
+                int_node2: node(name: 42) { earliestTime { timestamp } }
+              }
+            }
+            """,
+        )
+        graph = result["graph"]
+        assert graph["hasInt"] is True
+        assert graph["hasOther"] is True
+        assert graph["hasMissingInt"] is False
+        assert graph["int_node"]["earliestTime"]["timestamp"] == 1
+        assert graph["int_node2"]["earliestTime"]["timestamp"] == 3
+
+
+def test_addedge_and_edge_lookup_with_integer_endpoints():
+    """Edge mutations and lookups accept integer ids on src/dst."""
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir, create_index=True).start(PORT) as server:
+        client = server.get_client()
+        client.new_graph("g", "EVENT")
+
+        client.query("""
+            {
+              updateGraph(path: "g") {
+                e1: addEdge(time: 10, src: 1, dst: 2) { success }
+                e2: addEdge(time: 20, src: 2, dst: 3) { success }
+              }
+            }
+            """)
+
+        result = _query(
+            server,
+            """
+            {
+              graph(path: "g") {
+                hasIntEdge:  hasEdge(src: 1, dst: 2)
+                hasIntEdge2: hasEdge(src: 2, dst: 3)
+                hasNoEdge:   hasEdge(src: 1, dst: 3)
+                e1: edge(src: 1, dst: 2) { earliestTime { timestamp } }
+                e2: edge(src: 2, dst: 3) { earliestTime { timestamp } }
+              }
+            }
+            """,
+        )
+        graph = result["graph"]
+        assert graph["hasIntEdge"] is True
+        assert graph["hasIntEdge2"] is True
+        assert graph["hasNoEdge"] is False
+        assert graph["e1"]["earliestTime"]["timestamp"] == 10
+        assert graph["e2"]["earliestTime"]["timestamp"] == 20
+
+
+def test_view_transforms_with_integer_node_ids():
+    """`subgraph`, `excludeNodes`, and `sharedNeighbours` accept integer
+    node ids."""
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir, create_index=True).start(PORT) as server:
+        client = server.get_client()
+        client.new_graph("g", "EVENT")
+
+        # Build a small integer-id graph: 1 → 2, 1 → 3, 4 → 2 (so 1 and 4 share neighbour 2).
+        client.query("""
+            {
+              updateGraph(path: "g") {
+                e1: addEdge(time: 1, src: 1, dst: 2) { success }
+                e2: addEdge(time: 2, src: 1, dst: 3) { success }
+                e3: addEdge(time: 3, src: 4, dst: 2) { success }
+              }
+            }
+            """)
+
+        result = _query(
+            server,
+            """
+            {
+              graph(path: "g") {
+                sub:     subgraph(nodes: [1, 2])     { countNodes }
+                exclude: excludeNodes(nodes: [3])    { countNodes }
+                shared:  sharedNeighbours(selectedNodes: [1, 4]) { id }
+              }
+            }
+            """,
+        )
+        graph = result["graph"]
+        assert graph["sub"]["countNodes"] == 2
+        assert graph["exclude"]["countNodes"] == 3  # 1, 2, 4 (3 removed)
+        # `1` and `4` both connect to `2`, so 2 is the shared neighbour.
+        # Integer-indexed graph → `id` comes back as a number.
+        shared_ids = sorted(s["id"] for s in graph["shared"])
+        assert shared_ids == [2]
+
+
+def test_batch_addnodes_addedges_with_integer_ids():
+    """`addNodes` and `addEdges` accept integer ids in `name`/`src`/`dst`."""
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir, create_index=True).start(PORT) as server:
+        client = server.get_client()
+        client.new_graph("g", "EVENT")
+
+        client.query("""
+            {
+              updateGraph(path: "g") {
+                addNodes(nodes: [
+                  { name: 1,  updates: [{ time: 1, properties: [{key: "v", value: {i64: 10}}] }] }
+                  { name: 42, updates: [{ time: 2, properties: [{key: "v", value: {i64: 20}}] }] }
+                ])
+                addEdges(edges: [
+                  { src: 1, dst: 2,  updates: [{ time: 3, properties: [{key: "w", value: {f64: 1.5}}] }] }
+                  { src: 2, dst: 42, updates: [{ time: 4, properties: [{key: "w", value: {f64: 2.5}}] }] }
+                ])
+              }
+            }
+            """)
+
+        result = _query(
+            server,
+            """
+            {
+              graph(path: "g") {
+                n1: node(name: 1)           { properties { temporal { get(key: "v") { values } } } }
+                n2: node(name: 42)          { properties { temporal { get(key: "v") { values } } } }
+                e1: edge(src: 1, dst: 2)    { properties { temporal { get(key: "w") { values } } } }
+                e2: edge(src: 2, dst: 42)   { properties { temporal { get(key: "w") { values } } } }
+              }
+            }
+            """,
+        )
+        graph = result["graph"]
+        assert graph["n1"]["properties"]["temporal"]["get"]["values"] == [10]
+        assert graph["n2"]["properties"]["temporal"]["get"]["values"] == [20]
+        assert graph["e1"]["properties"]["temporal"]["get"]["values"] == [1.5]
+        assert graph["e2"]["properties"]["temporal"]["get"]["values"] == [2.5]
+
+
+def test_view_transforms_with_string_node_ids():
+    """`subgraph`, `excludeNodes`, and `sharedNeighbours` accept string node ids."""
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir, create_index=True).start(PORT) as server:
+        client = server.get_client()
+        client.new_graph("g", "EVENT")
+
+        # alice → bob, alice → carol, dave → bob (alice and dave share bob).
+        client.query("""
+            {
+              updateGraph(path: "g") {
+                e1: addEdge(time: 1, src: "alice", dst: "bob")   { success }
+                e2: addEdge(time: 2, src: "alice", dst: "carol") { success }
+                e3: addEdge(time: 3, src: "dave",  dst: "bob")   { success }
+              }
+            }
+            """)
+
+        result = _query(
+            server,
+            """
+            {
+              graph(path: "g") {
+                sub:     subgraph(nodes: ["alice", "bob"])      { countNodes }
+                exclude: excludeNodes(nodes: ["carol"])         { countNodes }
+                shared:  sharedNeighbours(selectedNodes: ["alice", "dave"]) { id }
+              }
+            }
+            """,
+        )
+        graph = result["graph"]
+        assert graph["sub"]["countNodes"] == 2
+        assert graph["exclude"]["countNodes"] == 3  # alice, bob, dave
+        shared_ids = sorted(s["id"] for s in graph["shared"])
+        assert shared_ids == ["bob"]
+
+
+def test_batch_addnodes_addedges_with_string_ids():
+    """`addNodes` and `addEdges` accept string ids in `name`/`src`/`dst`."""
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir, create_index=True).start(PORT) as server:
+        client = server.get_client()
+        client.new_graph("g", "EVENT")
+
+        client.query("""
+            {
+              updateGraph(path: "g") {
+                addNodes(nodes: [
+                  { name: "alice", updates: [{ time: 1, properties: [{key: "v", value: {i64: 10}}] }] }
+                  { name: "bob",   updates: [{ time: 2, properties: [{key: "v", value: {i64: 20}}] }] }
+                ])
+                addEdges(edges: [
+                  { src: "alice", dst: "bob",   updates: [{ time: 3, properties: [{key: "w", value: {f64: 1.5}}] }] }
+                  { src: "bob",   dst: "carol", updates: [{ time: 4, properties: [{key: "w", value: {f64: 2.5}}] }] }
+                ])
+              }
+            }
+            """)
+
+        result = _query(
+            server,
+            """
+            {
+              graph(path: "g") {
+                n1: node(name: "alice")                  { properties { temporal { get(key: "v") { values } } } }
+                n2: node(name: "bob")                    { properties { temporal { get(key: "v") { values } } } }
+                e1: edge(src: "alice", dst: "bob")       { properties { temporal { get(key: "w") { values } } } }
+                e2: edge(src: "bob",   dst: "carol")     { properties { temporal { get(key: "w") { values } } } }
+              }
+            }
+            """,
+        )
+        graph = result["graph"]
+        assert graph["n1"]["properties"]["temporal"]["get"]["values"] == [10]
+        assert graph["n2"]["properties"]["temporal"]["get"]["values"] == [20]
+        assert graph["e1"]["properties"]["temporal"]["get"]["values"] == [1.5]
+        assert graph["e2"]["properties"]["temporal"]["get"]["values"] == [2.5]
+
+
+def test_string_ids_remain_unchanged_for_existing_clients():
+    """Existing clients passing string node ids continue to work without
+    modification — the schema change is wire-compatible for strings."""
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir, create_index=True).start(PORT) as server:
+        client = server.get_client()
+        client.new_graph("g", "EVENT")
+
+        client.query("""
+            {
+              updateGraph(path: "g") {
+                addNode(time: 1, name: "alice") { success }
+                addEdge(time: 2, src: "alice", dst: "bob") { success }
+              }
+            }
+            """)
+
+        result = _query(
+            server,
+            """
+            {
+              graph(path: "g") {
+                node(name: "alice")         { earliestTime { timestamp } }
+                edge(src: "alice", dst: "bob") { earliestTime { timestamp } }
+              }
+            }
+            """,
+        )
+        assert result["graph"]["node"]["earliestTime"]["timestamp"] == 1
+        assert result["graph"]["edge"]["earliestTime"]["timestamp"] == 2
+
+
+def test_negative_integer_rejected():
+    """Schema rejects negative integers — `NodeId` only accepts non-negative."""
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir, create_index=True).start(PORT) as server:
+        client = server.get_client()
+        client.new_graph("g", "EVENT")
+
+        try:
+            client.query("""
+                {
+                  updateGraph(path: "g") {
+                    addNode(time: 1, name: -1) { success }
+                  }
+                }
+                """)
+            raise AssertionError(
+                "Expected schema-level rejection for negative integer NodeId"
+            )
+        except Exception as e:
+            assert "NodeId" in str(e) or "non-negative" in str(
+                e
+            ), f"Expected NodeId rejection, got: {e}"
diff --git a/python/tests/test_base_install/test_graphql/test_gql_same_timestamp_writes.py b/python/tests/test_base_install/test_graphql/test_gql_same_timestamp_writes.py
new file mode 100644
index 0000000000..d576a83a43
--- /dev/null
+++ b/python/tests/test_base_install/test_graphql/test_gql_same_timestamp_writes.py
@@ -0,0 +1,411 @@
+"""Every mutation that takes a `TimeInput` must auto-allocate a fresh
+`event_id` when the user passes only a timestamp (no `eventId`). Two writes
+at the same millisecond should therefore produce two distinct history
+entries, not be deduplicated.
+
+Before the `GqlTimeInput` refactor, every Number/String time input was
+coerced to `EventTime { t, event_id: 0 }`, so two same-ms writes shared the
+same composite key and the second silently overwrote the first.
+
+These tests pin down the fix on every mutation surface that takes a time.
+Each test checks both the timestamps in the history and the values, so a
+regression that drops a timestamp entry (not just a value) would still
+fail.
+"""
+
+import json
+import tempfile
+
+from raphtory.graphql import GraphServer
+
+from utils import PORT
+
+
+def _query(server, q: str) -> dict:
+    response = server.get_client().query(q)
+    return json.loads(response) if isinstance(response, str) else response
+
+
+def _new_event_graph(server):
+    server.get_client().new_graph("g", "EVENT")
+
+
+def _temporal_history(get_block: dict) -> tuple[list, list]:
+    """Return (timestamps, values) for a `temporal.get(key:)` GraphQL block
+    that selected `history { list { timestamp } } values`."""
+    timestamps = [h["timestamp"] for h in get_block["history"]["list"]]
+    return timestamps, get_block["values"]
+
+
+# ----- Top-level graph properties --------------------------------------------
+
+
+def test_add_properties_same_timestamp_appends():
+    """`addProperties` three times at the same ms → three history entries
+    with the same timestamp and distinct values."""
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir).start(PORT) as server:
+        _new_event_graph(server)
+        server.get_client().query("""
+            {
+              updateGraph(path: "g") {
+                a: addProperties(t: 100, properties: [{key: "x", value: {i64: 1}}])
+                b: addProperties(t: 100, properties: [{key: "x", value: {i64: 2}}])
+                c: addProperties(t: 100, properties: [{key: "x", value: {i64: 3}}])
+              }
+            }
+            """)
+        result = _query(
+            server,
+            """
+            { graph(path: "g") { properties { temporal { get(key: "x") {
+                history { list { timestamp } }
+                values
+            } } } } }
+            """,
+        )
+        ts, values = _temporal_history(result["graph"]["properties"]["temporal"]["get"])
+        assert ts == [100, 100, 100]
+        assert values == [1, 2, 3]
+
+
+# ----- Single-call addNode / addEdge / createNode ----------------------------
+
+
+def test_add_node_same_timestamp_appends():
+    """`addNode` twice at the same ms with different per-event properties →
+    both updates land. Verified on the node's `history` and on the
+    temporal property's `history`."""
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir).start(PORT) as server:
+        _new_event_graph(server)
+        server.get_client().query("""
+            {
+              updateGraph(path: "g") {
+                a: addNode(time: 100, name: "n", properties: [{key: "v", value: {i64: 1}}]) { success }
+                b: addNode(time: 100, name: "n", properties: [{key: "v", value: {i64: 2}}]) { success }
+              }
+            }
+            """)
+        result = _query(
+            server,
+            """
+            { graph(path: "g") {
+                node(name: "n") {
+                    history { list { timestamp } }
+                    properties { temporal { get(key: "v") {
+                        history { list { timestamp } }
+                        values
+                    } } }
+                }
+            } }
+            """,
+        )
+        node = result["graph"]["node"]
+        node_ts = [h["timestamp"] for h in node["history"]["list"]]
+        assert node_ts == [100, 100]
+        ts, values = _temporal_history(node["properties"]["temporal"]["get"])
+        assert ts == [100, 100]
+        assert values == [1, 2]
+
+
+def test_add_edge_same_timestamp_appends():
+    """`addEdge` twice at the same ms → both edge updates land. Verified on
+    the edge's `history` and on the temporal property's `history`."""
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir).start(PORT) as server:
+        _new_event_graph(server)
+        server.get_client().query("""
+            {
+              updateGraph(path: "g") {
+                a: addEdge(time: 100, src: "a", dst: "b", properties: [{key: "w", value: {i64: 1}}]) { success }
+                b: addEdge(time: 100, src: "a", dst: "b", properties: [{key: "w", value: {i64: 2}}]) { success }
+              }
+            }
+            """)
+        result = _query(
+            server,
+            """
+            { graph(path: "g") {
+                edge(src: "a", dst: "b") {
+                    history { list { timestamp } }
+                    properties { temporal { get(key: "w") {
+                        history { list { timestamp } }
+                        values
+                    } } }
+                }
+            } }
+            """,
+        )
+        edge = result["graph"]["edge"]
+        edge_ts = [h["timestamp"] for h in edge["history"]["list"]]
+        assert edge_ts == [100, 100]
+        ts, values = _temporal_history(edge["properties"]["temporal"]["get"])
+        assert ts == [100, 100]
+        assert values == [1, 2]
+
+
+def test_create_node_then_add_node_same_timestamp_appends():
+    """`createNode` followed by `addNode` at the same ms → both updates
+    land (createNode creates the node, addNode appends an update)."""
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir).start(PORT) as server:
+        _new_event_graph(server)
+        server.get_client().query("""
+            {
+              updateGraph(path: "g") {
+                a: createNode(time: 100, name: "n", properties: [{key: "v", value: {i64: 1}}]) { success }
+                b: addNode(time: 100, name: "n", properties: [{key: "v", value: {i64: 2}}]) { success }
+              }
+            }
+            """)
+        result = _query(
+            server,
+            """
+            { graph(path: "g") {
+                node(name: "n") {
+                    history { list { timestamp } }
+                    properties { temporal { get(key: "v") {
+                        history { list { timestamp } }
+                        values
+                    } } }
+                }
+            } }
+            """,
+        )
+        node = result["graph"]["node"]
+        node_ts = [h["timestamp"] for h in node["history"]["list"]]
+        assert node_ts == [100, 100]
+        ts, values = _temporal_history(node["properties"]["temporal"]["get"])
+        assert ts == [100, 100]
+        assert values == [1, 2]
+
+
+# ----- MutableNode.addUpdates / MutableEdge.addUpdates -----------------------
+
+
+def test_mutable_node_add_updates_same_timestamp_appends():
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir).start(PORT) as server:
+        _new_event_graph(server)
+        server.get_client().query("""
+            { updateGraph(path: "g") { addNode(time: 0, name: "n") { success } } }
+            """)
+        server.get_client().query("""
+            {
+              updateGraph(path: "g") {
+                node(name: "n") {
+                  a: addUpdates(time: 100, properties: [{key: "v", value: {i64: 1}}])
+                  b: addUpdates(time: 100, properties: [{key: "v", value: {i64: 2}}])
+                }
+              }
+            }
+            """)
+        result = _query(
+            server,
+            """
+            { graph(path: "g") {
+                node(name: "n") {
+                    history { list { timestamp } }
+                    properties { temporal { get(key: "v") {
+                        history { list { timestamp } }
+                        values
+                    } } }
+                }
+            } }
+            """,
+        )
+        node = result["graph"]["node"]
+        node_ts = [h["timestamp"] for h in node["history"]["list"]]
+        # t=0 from the seed addNode plus two t=100 updates.
+        assert node_ts == [0, 100, 100]
+        ts, values = _temporal_history(node["properties"]["temporal"]["get"])
+        assert ts == [100, 100]
+        assert values == [1, 2]
+
+
+def test_mutable_edge_add_updates_same_timestamp_appends():
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir).start(PORT) as server:
+        _new_event_graph(server)
+        server.get_client().query("""
+            { updateGraph(path: "g") { addEdge(time: 0, src: "a", dst: "b") { success } } }
+            """)
+        server.get_client().query("""
+            {
+              updateGraph(path: "g") {
+                edge(src: "a", dst: "b") {
+                  x: addUpdates(time: 100, properties: [{key: "w", value: {i64: 1}}])
+                  y: addUpdates(time: 100, properties: [{key: "w", value: {i64: 2}}])
+                }
+              }
+            }
+            """)
+        result = _query(
+            server,
+            """
+            { graph(path: "g") {
+                edge(src: "a", dst: "b") {
+                    history { list { timestamp } }
+                    properties { temporal { get(key: "w") {
+                        history { list { timestamp } }
+                        values
+                    } } }
+                }
+            } }
+            """,
+        )
+        edge = result["graph"]["edge"]
+        edge_ts = [h["timestamp"] for h in edge["history"]["list"]]
+        # t=0 from the seed addEdge plus two t=100 updates.
+        assert edge_ts == [0, 100, 100]
+        ts, values = _temporal_history(edge["properties"]["temporal"]["get"])
+        assert ts == [100, 100]
+        assert values == [1, 2]
+
+
+# ----- Batch addNodes / addEdges --------------------------------------------
+
+
+def test_add_nodes_batch_same_timestamp_appends():
+    """A single batch `addNodes` with three updates at the same ms on the
+    same node should produce three history entries."""
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir).start(PORT) as server:
+        _new_event_graph(server)
+        server.get_client().query("""
+            {
+              updateGraph(path: "g") {
+                addNodes(nodes: [
+                  { name: "n", updates: [
+                    { time: 100, properties: [{key: "v", value: {i64: 1}}] }
+                    { time: 100, properties: [{key: "v", value: {i64: 2}}] }
+                    { time: 100, properties: [{key: "v", value: {i64: 3}}] }
+                  ] }
+                ])
+              }
+            }
+            """)
+        result = _query(
+            server,
+            """
+            { graph(path: "g") {
+                node(name: "n") {
+                    history { list { timestamp } }
+                    properties { temporal { get(key: "v") {
+                        history { list { timestamp } }
+                        values
+                    } } }
+                }
+            } }
+            """,
+        )
+        node = result["graph"]["node"]
+        node_ts = [h["timestamp"] for h in node["history"]["list"]]
+        assert node_ts == [100, 100, 100]
+        ts, values = _temporal_history(node["properties"]["temporal"]["get"])
+        assert ts == [100, 100, 100]
+        assert values == [1, 2, 3]
+
+
+def test_add_edges_batch_same_timestamp_appends():
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir).start(PORT) as server:
+        _new_event_graph(server)
+        server.get_client().query("""
+            {
+              updateGraph(path: "g") {
+                addEdges(edges: [
+                  { src: "a", dst: "b", updates: [
+                    { time: 100, properties: [{key: "w", value: {i64: 1}}] }
+                    { time: 100, properties: [{key: "w", value: {i64: 2}}] }
+                    { time: 100, properties: [{key: "w", value: {i64: 3}}] }
+                  ] }
+                ])
+              }
+            }
+            """)
+        result = _query(
+            server,
+            """
+            { graph(path: "g") {
+                edge(src: "a", dst: "b") {
+                    history { list { timestamp } }
+                    properties { temporal { get(key: "w") {
+                        history { list { timestamp } }
+                        values
+                    } } }
+                }
+            } }
+            """,
+        )
+        edge = result["graph"]["edge"]
+        edge_ts = [h["timestamp"] for h in edge["history"]["list"]]
+        assert edge_ts == [100, 100, 100]
+        ts, values = _temporal_history(edge["properties"]["temporal"]["get"])
+        assert ts == [100, 100, 100]
+        assert values == [1, 2, 3]
+
+
+# ----- Persistent graph: deleteEdge -----------------------------------------
+
+
+def test_delete_edge_same_timestamp_appends():
+    """Multiple `deleteEdge` calls at the same ms on a persistent graph all
+    land in the deletion history with the same timestamp."""
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir).start(PORT) as server:
+        client = server.get_client()
+        client.new_graph("g", "PERSISTENT")
+        client.query("""
+            {
+              updateGraph(path: "g") {
+                a: addEdge(time: 1, src: "a", dst: "b") { success }
+                d1: deleteEdge(time: 100, src: "a", dst: "b") { success }
+                d2: deleteEdge(time: 100, src: "a", dst: "b") { success }
+              }
+            }
+            """)
+        result = _query(
+            server,
+            """
+            { graph(path: "g") {
+                edge(src: "a", dst: "b") { deletions { list { timestamp } } }
+            } }
+            """,
+        )
+        timestamps = [
+            d["timestamp"] for d in result["graph"]["edge"]["deletions"]["list"]
+        ]
+        assert timestamps == [100, 100]
+
+
+# ----- Object form pins event_id explicitly ---------------------------------
+
+
+def test_object_time_input_distinct_event_ids_append():
+    """Two writes at the same timestamp with distinct explicit event_ids
+    both land — the user-provided event_ids partition the events."""
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir).start(PORT) as server:
+        _new_event_graph(server)
+        server.get_client().query("""
+            {
+              updateGraph(path: "g") {
+                a: addProperties(t: {timestamp: 100, eventId: 0}, properties: [{key: "x", value: {i64: 1}}])
+                b: addProperties(t: {timestamp: 100, eventId: 1}, properties: [{key: "x", value: {i64: 2}}])
+              }
+            }
+            """)
+        result = _query(
+            server,
+            """
+            { graph(path: "g") { properties { temporal { get(key: "x") {
+                history { list { timestamp } }
+                values
+            } } } } }
+            """,
+        )
+        ts, values = _temporal_history(result["graph"]["properties"]["temporal"]["get"])
+        assert ts == [100, 100]
+        assert values == [1, 2]
diff --git a/python/tests/test_base_install/test_graphql/test_gql_temporal_aggregates.py b/python/tests/test_base_install/test_graphql/test_gql_temporal_aggregates.py
new file mode 100644
index 0000000000..628745e629
--- /dev/null
+++ b/python/tests/test_base_install/test_graphql/test_gql_temporal_aggregates.py
@@ -0,0 +1,597 @@
+import json
+import tempfile
+
+from utils import PORT, run_group_graphql_test
+from raphtory import Graph
+from raphtory.graphql import GraphServer
+
+
+def create_graph() -> Graph:
+    graph = Graph()
+
+    # Bare node event so "A" exists at t=50 before any score updates
+    graph.add_node(50, "A")
+    # Node "A" with a numeric temporal property "score" at 4 timestamps
+    graph.add_node(100, "A", properties={"score": 10})
+    graph.add_node(200, "A", properties={"score": 20})
+    graph.add_node(300, "A", properties={"score": 30})
+    graph.add_node(400, "A", properties={"score": 40})
+
+    # Edge "A -> B" with "weight" on two layers
+    graph.add_edge(100, "A", "B", properties={"weight": 1.0}, layer="layer1")
+    graph.add_edge(200, "A", "B", properties={"weight": 2.0}, layer="layer1")
+    graph.add_edge(300, "A", "B", properties={"weight": 3.0}, layer="layer2")
+    graph.add_edge(400, "A", "B", properties={"weight": 4.0}, layer="layer2")
+
+    return graph
+
+
+def test_node_temporal_aggregates():
+    graph = create_graph()
+    queries_and_expected_outputs = []
+
+    # full timeline: score = [10, 20, 30, 40]
+    query = """
+    {
+      graph(path: "g") {
+        node(name: "A") {
+          properties {
+            temporal {
+              get(key: "score") {
+                sum
+                mean
+                average
+                count
+                min { time { timestamp } value }
+                max { time { timestamp } value }
+                median { time { timestamp } value }
+              }
+            }
+          }
+        }
+      }
+    }
+    """
+    expected_output = {
+        "graph": {
+            "node": {
+                "properties": {
+                    "temporal": {
+                        "get": {
+                            "sum": 100,
+                            "mean": 25.0,
+                            "average": 25.0,
+                            "count": 4,
+                            "min": {"time": {"timestamp": 100}, "value": 10},
+                            "max": {"time": {"timestamp": 400}, "value": 40},
+                            # lower median on even-length input: sorted[(4-1)/2] = index 1
+                            "median": {"time": {"timestamp": 200}, "value": 20},
+                        }
+                    }
+                }
+            }
+        }
+    }
+    queries_and_expected_outputs.append((query, expected_output))
+
+    # windowed [150, 350): score = [20, 30]
+    query = """
+    {
+      graph(path: "g") {
+        window(start: 150, end: 350) {
+          node(name: "A") {
+            properties {
+              temporal {
+                get(key: "score") {
+                  sum
+                  mean
+                  count
+                  min { time { timestamp } value }
+                  max { time { timestamp } value }
+                  median { time { timestamp } value }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    """
+    expected_output = {
+        "graph": {
+            "window": {
+                "node": {
+                    "properties": {
+                        "temporal": {
+                            "get": {
+                                "sum": 50,
+                                "mean": 25.0,
+                                "count": 2,
+                                "min": {"time": {"timestamp": 200}, "value": 20},
+                                "max": {"time": {"timestamp": 300}, "value": 30},
+                                # lower median of [20, 30] => index 0
+                                "median": {"time": {"timestamp": 200}, "value": 20},
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    queries_and_expected_outputs.append((query, expected_output))
+
+    # window with no updates in range: score property doesn't exist => get is null
+    query = """
+    {
+      graph(path: "g") {
+        window(start: 40, end: 60) {
+          node(name: "A") {
+            properties {
+              temporal {
+                get(key: "score") {
+                  sum
+                  mean
+                  count
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    """
+    expected_output = {
+        "graph": {
+            "window": {
+                "node": {
+                    "properties": {
+                        "temporal": {"get": {"sum": None, "mean": None, "count": 0}}
+                    }
+                }
+            }
+        }
+    }
+    queries_and_expected_outputs.append((query, expected_output))
+
+    run_group_graphql_test(queries_and_expected_outputs, graph)
+
+
+def create_non_numeric_graph() -> Graph:
+    graph = Graph()
+    # string-valued temporal property (insertion order != sorted order, so
+    # min/max/median land on interior timestamps)
+    graph.add_node(1, "A", properties={"name": "cherry"})
+    graph.add_node(2, "A", properties={"name": "apple"})
+    graph.add_node(3, "A", properties={"name": "banana"})
+    graph.add_node(4, "A", properties={"name": "date"})
+    # bool-valued temporal property, mixed so True/False appear multiple times
+    graph.add_node(1, "A", properties={"flag": True})
+    graph.add_node(2, "A", properties={"flag": False})
+    graph.add_node(3, "A", properties={"flag": True})
+    graph.add_node(4, "A", properties={"flag": False})
+    graph.add_node(5, "A", properties={"flag": True})
+    return graph
+
+
+def test_temporal_aggregates_on_non_numeric():
+    """Pin down semantics for aggregates on non-numeric temporal properties.
+
+    - Strings: `sum` concatenates (strings are additive), `min/max/median` work
+      lexicographically, `mean` is null (not f64-convertible).
+    - Bools: `sum`/`mean` are null (not additive, not f64-convertible), but
+      `min/max/median` work (False < True).
+    """
+    graph = create_non_numeric_graph()
+    queries_and_expected_outputs = []
+
+    # strings
+    query = """
+    {
+      graph(path: "g") {
+        node(name: "A") {
+          properties {
+            temporal {
+              get(key: "name") {
+                sum
+                mean
+                average
+                count
+                min { time { timestamp } value }
+                max { time { timestamp } value }
+                median { time { timestamp } value }
+              }
+            }
+          }
+        }
+      }
+    }
+    """
+    # timeline: cherry(t=1), apple(t=2), banana(t=3), date(t=4)
+    # sorted lex:        apple(t=2) < banana(t=3) < cherry(t=1) < date(t=4)
+    expected_output = {
+        "graph": {
+            "node": {
+                "properties": {
+                    "temporal": {
+                        "get": {
+                            # concatenation in insertion order
+                            "sum": "cherryapplebananadate",
+                            "mean": None,
+                            "average": None,
+                            "count": 4,
+                            "min": {"time": {"timestamp": 2}, "value": "apple"},
+                            "max": {"time": {"timestamp": 4}, "value": "date"},
+                            # lower median of len=4 is sorted[(4-1)/2] = index 1
+                            "median": {"time": {"timestamp": 3}, "value": "banana"},
+                        }
+                    }
+                }
+            }
+        }
+    }
+    queries_and_expected_outputs.append((query, expected_output))
+
+    # bools
+    query = """
+    {
+      graph(path: "g") {
+        node(name: "A") {
+          properties {
+            temporal {
+              get(key: "flag") {
+                sum
+                mean
+                average
+                count
+                min { time { timestamp } value }
+                max { time { timestamp } value }
+                median { time { timestamp } value }
+              }
+            }
+          }
+        }
+      }
+    }
+    """
+    # timeline: True(t=1), False(t=2), True(t=3), False(t=4), True(t=5)
+    # min fold keeps first smaller value encountered => first False at t=2
+    # max fold keeps first larger-or-equal value encountered => True at t=1
+    # median: stable sort by value gives [False@2, False@4, True@1, True@3, True@5]
+    # lower median of len=5 => sorted[(5-1)/2] = index 2 = True at t=1
+    expected_output = {
+        "graph": {
+            "node": {
+                "properties": {
+                    "temporal": {
+                        "get": {
+                            "sum": None,
+                            "mean": None,
+                            "average": None,
+                            "count": 5,
+                            "min": {"time": {"timestamp": 2}, "value": False},
+                            "max": {"time": {"timestamp": 1}, "value": True},
+                            "median": {"time": {"timestamp": 1}, "value": True},
+                        }
+                    }
+                }
+            }
+        }
+    }
+    queries_and_expected_outputs.append((query, expected_output))
+
+    run_group_graphql_test(queries_and_expected_outputs, graph)
+
+
+def test_edge_temporal_aggregates_across_layers():
+    graph = create_graph()
+    queries_and_expected_outputs = []
+
+    # full (both layers): weight = [1.0, 2.0, 3.0, 4.0]
+    query = """
+    {
+      graph(path: "g") {
+        edge(src: "A", dst: "B") {
+          properties {
+            temporal {
+              get(key: "weight") {
+                sum
+                mean
+                count
+                min { time { timestamp } value }
+                max { time { timestamp } value }
+                median { time { timestamp } value }
+              }
+            }
+          }
+        }
+      }
+    }
+    """
+    expected_output = {
+        "graph": {
+            "edge": {
+                "properties": {
+                    "temporal": {
+                        "get": {
+                            "sum": 10.0,
+                            "mean": 2.5,
+                            "count": 4,
+                            "min": {"time": {"timestamp": 100}, "value": 1.0},
+                            "max": {"time": {"timestamp": 400}, "value": 4.0},
+                            "median": {"time": {"timestamp": 200}, "value": 2.0},
+                        }
+                    }
+                }
+            }
+        }
+    }
+    queries_and_expected_outputs.append((query, expected_output))
+
+    # layer1 only: weight = [1.0, 2.0]
+    query = """
+    {
+      graph(path: "g") {
+        layer(name: "layer1") {
+          edge(src: "A", dst: "B") {
+            properties {
+              temporal {
+                get(key: "weight") {
+                  sum
+                  mean
+                  count
+                  min { time { timestamp } value }
+                  max { time { timestamp } value }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    """
+    expected_output = {
+        "graph": {
+            "layer": {
+                "edge": {
+                    "properties": {
+                        "temporal": {
+                            "get": {
+                                "sum": 3.0,
+                                "mean": 1.5,
+                                "count": 2,
+                                "min": {"time": {"timestamp": 100}, "value": 1.0},
+                                "max": {"time": {"timestamp": 200}, "value": 2.0},
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    queries_and_expected_outputs.append((query, expected_output))
+
+    # layer2 only: weight = [3.0, 4.0]
+    query = """
+    {
+      graph(path: "g") {
+        layer(name: "layer2") {
+          edge(src: "A", dst: "B") {
+            properties {
+              temporal {
+                get(key: "weight") {
+                  sum
+                  mean
+                  count
+                  min { time { timestamp } value }
+                  max { time { timestamp } value }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    """
+    expected_output = {
+        "graph": {
+            "layer": {
+                "edge": {
+                    "properties": {
+                        "temporal": {
+                            "get": {
+                                "sum": 7.0,
+                                "mean": 3.5,
+                                "count": 2,
+                                "min": {"time": {"timestamp": 300}, "value": 3.0},
+                                "max": {"time": {"timestamp": 400}, "value": 4.0},
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    queries_and_expected_outputs.append((query, expected_output))
+
+    # combined: windowed + layer-filtered (layer1, window [150, 400))
+    # => weight = [2.0]
+    query = """
+    {
+      graph(path: "g") {
+        layer(name: "layer1") {
+          window(start: 150, end: 400) {
+            edge(src: "A", dst: "B") {
+              properties {
+                temporal {
+                  get(key: "weight") {
+                    sum
+                    mean
+                    count
+                    min { time { timestamp } value }
+                    max { time { timestamp } value }
+                    median { time { timestamp } value }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    """
+    expected_output = {
+        "graph": {
+            "layer": {
+                "window": {
+                    "edge": {
+                        "properties": {
+                            "temporal": {
+                                "get": {
+                                    "sum": 2.0,
+                                    "mean": 2.0,
+                                    "count": 1,
+                                    "min": {"time": {"timestamp": 200}, "value": 2.0},
+                                    "max": {"time": {"timestamp": 200}, "value": 2.0},
+                                    "median": {
+                                        "time": {"timestamp": 200},
+                                        "value": 2.0,
+                                    },
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    queries_and_expected_outputs.append((query, expected_output))
+
+    run_group_graphql_test(queries_and_expected_outputs, graph)
+
+
+def _run_typed_accessors_cases(graph, cases):
+    """Run queries against a fresh server.
+
+    `cases` is a list of `(query, expected, transform)` where `transform` is
+    applied to both the response and the expected value before comparison
+    (needed for fields like `unique` whose ordering is non-deterministic).
+    """
+    tmp_work_dir = tempfile.mkdtemp()
+    with GraphServer(tmp_work_dir, create_index=True).start(PORT) as server:
+        client = server.get_client()
+        client.send_graph(path="g", graph=graph)
+        for query, expected, transform in cases:
+            response = client.query(query)
+            response_dict = (
+                json.loads(response) if isinstance(response, str) else response
+            )
+            actual = transform(response_dict) if transform else response_dict
+            expected_t = transform(expected) if transform else expected
+            assert actual == expected_t, f"Expected:\n{expected_t}\nGot:\n{actual}"
+
+
+def _sort_unique(path):
+    """Returns a transform that sorts the `unique` list at the given dict path."""
+
+    def transform(d):
+        d = json.loads(json.dumps(d))  # deep copy
+        cur = d
+        for step in path:
+            cur = cur[step]
+        cur["unique"] = sorted(cur["unique"])
+        return d
+
+    return transform
+
+
+def test_temporal_property_typed_accessors():
+    """`values`, `latest`, `at`, and `unique` on `TemporalProperty` return
+    properly typed values (numbers stay numbers, bools stay bools, etc.)."""
+    graph = create_graph()  # node "A" with score [10, 20, 30, 40] at t=100..400
+    # bool property on the same node so we exercise non-numeric typing too
+    graph.add_node(100, "A", properties={"flag": True})
+    graph.add_node(200, "A", properties={"flag": False})
+    graph.add_node(300, "A", properties={"flag": True})
+
+    cases = []
+    path = ["graph", "node", "properties", "temporal", "get"]
+
+    # numeric values stay numeric; `at(t)` returns the latest value at-or-before t
+    query = """
+    {
+      graph(path: "g") {
+        node(name: "A") {
+          properties {
+            temporal {
+              get(key: "score") {
+                values
+                latest
+                atEarly: at(t: 50)
+                atMid:   at(t: 250)
+                atExact: at(t: 200)
+                atLate:  at(t: 1000)
+                unique
+              }
+            }
+          }
+        }
+      }
+    }
+    """
+    expected = {
+        "graph": {
+            "node": {
+                "properties": {
+                    "temporal": {
+                        "get": {
+                            "values": [10, 20, 30, 40],
+                            "latest": 40,
+                            "atEarly": None,
+                            "atMid": 20,
+                            "atExact": 20,
+                            "atLate": 40,
+                            "unique": [10, 20, 30, 40],
+                        }
+                    }
+                }
+            }
+        }
+    }
+    cases.append((query, expected, _sort_unique(path)))
+
+    # bools stay bools through values/latest/unique
+    query = """
+    {
+      graph(path: "g") {
+        node(name: "A") {
+          properties {
+            temporal {
+              get(key: "flag") {
+                values
+                latest
+                unique
+              }
+            }
+          }
+        }
+      }
+    }
+    """
+    expected = {
+        "graph": {
+            "node": {
+                "properties": {
+                    "temporal": {
+                        "get": {
+                            "values": [True, False, True],
+                            "latest": True,
+                            "unique": [False, True],
+                        }
+                    }
+                }
+            }
+        }
+    }
+    cases.append((query, expected, _sort_unique(path)))
+
+    _run_typed_accessors_cases(graph, cases)
diff --git a/python/tests/test_base_install/test_graphql/test_graph_file_time_stats.py b/python/tests/test_base_install/test_graphql/test_graph_file_time_stats.py
index 6157f48258..63e6de6dba 100644
--- a/python/tests/test_base_install/test_graphql/test_graph_file_time_stats.py
+++ b/python/tests/test_base_install/test_graphql/test_graph_file_time_stats.py
@@ -26,11 +26,13 @@ def test_graph_file_time_stats():
         gql_last_opened_time = result["graph"]["lastOpened"]
         gql_last_updated_time = result["graph"]["lastUpdated"]
 
-        graph_file_path = os.path.join(graph_file_path, "graph")
-        file_stats = os.stat(graph_file_path)
-        created_time_fs = file_stats.st_ctime * 1000
-        last_opened_time_fs = file_stats.st_atime * 1000
-        last_updated_time_fs = file_stats.st_mtime * 1000
+        raph_file_path = os.path.join(graph_file_path, ".raph")
+        raph_file_stats = os.stat(raph_file_path)
+        meta_file_path = os.path.join(graph_file_path, "data0", ".meta")
+        meta_file_stats = os.stat(meta_file_path)
+        created_time_fs = raph_file_stats.st_ctime * 1000
+        last_opened_time_fs = meta_file_stats.st_atime * 1000
+        last_updated_time_fs = meta_file_stats.st_mtime * 1000
 
         assert (
             abs(gql_created_time - created_time_fs) < 1000
diff --git a/python/tests/test_base_install/test_graphql/test_node_sorting.py b/python/tests/test_base_install/test_graphql/test_node_sorting.py
index 9a091dd17c..52ebc6f07b 100644
--- a/python/tests/test_base_install/test_graphql/test_node_sorting.py
+++ b/python/tests/test_base_install/test_graphql/test_node_sorting.py
@@ -88,7 +88,7 @@ def test_graph_node_sort_by_nothing(graph):
             }
         }
     }
-    run_graphql_test(query, expected_output, graph)
+    run_graphql_test(query, expected_output, graph, sort_output=True)
 
 
 @pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
@@ -245,12 +245,16 @@ def test_graph_nodes_sort_by_prop2(graph):
 @pytest.mark.parametrize("graph", [EVENT_GRAPH, PERSISTENT_GRAPH])
 def test_graph_nodes_sort_by_prop3(graph):
     query = """
-        {
+        query {
           graph(path: "g") {
             nodes {
-              sorted(sortBys: [{property: "prop3"}]) {
+              sorted(sortBys: [{ property: "prop3" }]) {
                 list {
-                  id
+                  properties {
+                    get(key: "prop3") {
+                      value
+                    }
+                  }
                 }
               }
             }
@@ -260,7 +264,14 @@ def test_graph_nodes_sort_by_prop3(graph):
     expected_output = {
         "graph": {
             "nodes": {
-                "sorted": {"list": [{"id": "c"}, {"id": "a"}, {"id": "b"}, {"id": "d"}]}
+                "sorted": {
+                    "list": [
+                        {"properties": {"get": {"value": "ayz123"}}},
+                        {"properties": {"get": {"value": "xyz123"}}},
+                        {"properties": {"get": {"value": "xyz123"}}},
+                        {"properties": {"get": {"value": "xyz123"}}},
+                    ]
+                }
             }
         }
     }
diff --git a/python/tests/test_base_install/test_graphql/test_rolling_expanding.py b/python/tests/test_base_install/test_graphql/test_rolling_expanding.py
index 62a9b82a2c..1ae7a29005 100644
--- a/python/tests/test_base_install/test_graphql/test_rolling_expanding.py
+++ b/python/tests/test_base_install/test_graphql/test_rolling_expanding.py
@@ -627,7 +627,7 @@ def test_nodes():
                         {
                             "page": [
                                 {
-                                    "id": "1",
+                                    "id": 1,
                                     "degree": 1,
                                     "start": {"timestamp": 1},
                                     "end": {"timestamp": 2},
@@ -638,7 +638,7 @@ def test_nodes():
                         {
                             "page": [
                                 {
-                                    "id": "1",
+                                    "id": 1,
                                     "degree": 2,
                                     "start": {"timestamp": 2},
                                     "end": {"timestamp": 3},
@@ -649,7 +649,7 @@ def test_nodes():
                         {
                             "page": [
                                 {
-                                    "id": "1",
+                                    "id": 1,
                                     "degree": 2,
                                     "start": {"timestamp": 3},
                                     "end": {"timestamp": 4},
@@ -660,7 +660,7 @@ def test_nodes():
                         {
                             "page": [
                                 {
-                                    "id": "1",
+                                    "id": 1,
                                     "degree": 1,
                                     "start": {"timestamp": 4},
                                     "end": {"timestamp": 5},
@@ -671,7 +671,7 @@ def test_nodes():
                         {
                             "page": [
                                 {
-                                    "id": "1",
+                                    "id": 1,
                                     "degree": 0,
                                     "start": {"timestamp": 5},
                                     "end": {"timestamp": 6},
@@ -685,7 +685,7 @@ def test_nodes():
                         {
                             "page": [
                                 {
-                                    "id": "1",
+                                    "id": 1,
                                     "degree": 1,
                                     "start": {"timestamp": 4},
                                     "end": {"timestamp": 5},
@@ -696,7 +696,7 @@ def test_nodes():
                         {
                             "page": [
                                 {
-                                    "id": "1",
+                                    "id": 1,
                                     "degree": 0,
                                     "start": {"timestamp": 5},
                                     "end": {"timestamp": 6},
@@ -712,7 +712,7 @@ def test_nodes():
                             {
                                 "page": [
                                     {
-                                        "id": "1",
+                                        "id": 1,
                                         "degree": 2,
                                         "start": {"timestamp": 2},
                                         "end": {"timestamp": 3},
@@ -724,7 +724,7 @@ def test_nodes():
                             {
                                 "page": [
                                     {
-                                        "id": "1",
+                                        "id": 1,
                                         "degree": 2,
                                         "start": {"timestamp": 2},
                                         "end": {"timestamp": 4},
@@ -736,7 +736,7 @@ def test_nodes():
                             {
                                 "page": [
                                     {
-                                        "id": "1",
+                                        "id": 1,
                                         "degree": 2,
                                         "start": {"timestamp": 2},
                                         "end": {"timestamp": 5},
@@ -748,7 +748,7 @@ def test_nodes():
                             {
                                 "page": [
                                     {
-                                        "id": "1",
+                                        "id": 1,
                                         "degree": 2,
                                         "start": {"timestamp": 2},
                                         "end": {"timestamp": 6},
@@ -763,7 +763,7 @@ def test_nodes():
                             {
                                 "page": [
                                     {
-                                        "id": "1",
+                                        "id": 1,
                                         "degree": 2,
                                         "start": {"timestamp": 2},
                                         "end": {"timestamp": 5},
@@ -775,7 +775,7 @@ def test_nodes():
                             {
                                 "page": [
                                     {
-                                        "id": "1",
+                                        "id": 1,
                                         "degree": 2,
                                         "start": {"timestamp": 2},
                                         "end": {"timestamp": 6},
@@ -890,7 +890,7 @@ def test_path():
                             {
                                 "page": [
                                     {
-                                        "id": "2",
+                                        "id": 2,
                                         "degree": 1,
                                         "start": {"timestamp": 1},
                                         "end": {"timestamp": 2},
@@ -901,7 +901,7 @@ def test_path():
                             {
                                 "page": [
                                     {
-                                        "id": "2",
+                                        "id": 2,
                                         "degree": 1,
                                         "start": {"timestamp": 2},
                                         "end": {"timestamp": 3},
@@ -912,7 +912,7 @@ def test_path():
                             {
                                 "page": [
                                     {
-                                        "id": "2",
+                                        "id": 2,
                                         "degree": 1,
                                         "start": {"timestamp": 3},
                                         "end": {"timestamp": 4},
@@ -923,7 +923,7 @@ def test_path():
                             {
                                 "page": [
                                     {
-                                        "id": "2",
+                                        "id": 2,
                                         "degree": 0,
                                         "start": {"timestamp": 4},
                                         "end": {"timestamp": 5},
@@ -934,7 +934,7 @@ def test_path():
                             {
                                 "page": [
                                     {
-                                        "id": "2",
+                                        "id": 2,
                                         "degree": 0,
                                         "start": {"timestamp": 5},
                                         "end": {"timestamp": 6},
@@ -948,7 +948,7 @@ def test_path():
                             {
                                 "page": [
                                     {
-                                        "id": "2",
+                                        "id": 2,
                                         "degree": 0,
                                         "start": {"timestamp": 4},
                                         "end": {"timestamp": 5},
@@ -959,7 +959,7 @@ def test_path():
                             {
                                 "page": [
                                     {
-                                        "id": "2",
+                                        "id": 2,
                                         "degree": 0,
                                         "start": {"timestamp": 5},
                                         "end": {"timestamp": 6},
@@ -975,7 +975,7 @@ def test_path():
                                 {
                                     "page": [
                                         {
-                                            "id": "2",
+                                            "id": 2,
                                             "degree": 1,
                                             "start": {"timestamp": 2},
                                             "end": {"timestamp": 3},
@@ -987,7 +987,7 @@ def test_path():
                                 {
                                     "page": [
                                         {
-                                            "id": "2",
+                                            "id": 2,
                                             "degree": 1,
                                             "start": {"timestamp": 2},
                                             "end": {"timestamp": 4},
@@ -999,7 +999,7 @@ def test_path():
                                 {
                                     "page": [
                                         {
-                                            "id": "2",
+                                            "id": 2,
                                             "degree": 1,
                                             "start": {"timestamp": 2},
                                             "end": {"timestamp": 5},
@@ -1011,7 +1011,7 @@ def test_path():
                                 {
                                     "page": [
                                         {
-                                            "id": "2",
+                                            "id": 2,
                                             "degree": 1,
                                             "start": {"timestamp": 2},
                                             "end": {"timestamp": 6},
@@ -1026,7 +1026,7 @@ def test_path():
                                 {
                                     "page": [
                                         {
-                                            "id": "2",
+                                            "id": 2,
                                             "degree": 1,
                                             "start": {"timestamp": 2},
                                             "end": {"timestamp": 5},
@@ -1038,7 +1038,7 @@ def test_path():
                                 {
                                     "page": [
                                         {
-                                            "id": "2",
+                                            "id": 2,
                                             "degree": 1,
                                             "start": {"timestamp": 2},
                                             "end": {"timestamp": 6},
@@ -1340,7 +1340,7 @@ def test_edges():
                         {
                             "page": [
                                 {
-                                    "id": ["1", "2"],
+                                    "id": [1, 2],
                                     "start": {"timestamp": 1},
                                     "end": {"timestamp": 2},
                                     "earliestTime": {"timestamp": 1},
@@ -1350,7 +1350,7 @@ def test_edges():
                         {
                             "page": [
                                 {
-                                    "id": ["1", "2"],
+                                    "id": [1, 2],
                                     "start": {"timestamp": 2},
                                     "end": {"timestamp": 3},
                                     "earliestTime": {"timestamp": 2},
@@ -1360,7 +1360,7 @@ def test_edges():
                         {
                             "page": [
                                 {
-                                    "id": ["1", "2"],
+                                    "id": [1, 2],
                                     "start": {"timestamp": 3},
                                     "end": {"timestamp": 4},
                                     "earliestTime": {"timestamp": 3},
@@ -1370,7 +1370,7 @@ def test_edges():
                         {
                             "page": [
                                 {
-                                    "id": ["1", "2"],
+                                    "id": [1, 2],
                                     "start": {"timestamp": 4},
                                     "end": {"timestamp": 5},
                                     "earliestTime": {"timestamp": None},
@@ -1380,7 +1380,7 @@ def test_edges():
                         {
                             "page": [
                                 {
-                                    "id": ["1", "2"],
+                                    "id": [1, 2],
                                     "start": {"timestamp": 5},
                                     "end": {"timestamp": 6},
                                     "earliestTime": {"timestamp": None},
@@ -1393,7 +1393,7 @@ def test_edges():
                         {
                             "page": [
                                 {
-                                    "id": ["1", "2"],
+                                    "id": [1, 2],
                                     "start": {"timestamp": 4},
                                     "end": {"timestamp": 5},
                                     "earliestTime": {"timestamp": None},
@@ -1403,7 +1403,7 @@ def test_edges():
                         {
                             "page": [
                                 {
-                                    "id": ["1", "2"],
+                                    "id": [1, 2],
                                     "start": {"timestamp": 5},
                                     "end": {"timestamp": 6},
                                     "earliestTime": {"timestamp": None},
@@ -1418,7 +1418,7 @@ def test_edges():
                             {
                                 "page": [
                                     {
-                                        "id": ["1", "2"],
+                                        "id": [1, 2],
                                         "start": {"timestamp": 2},
                                         "end": {"timestamp": 3},
                                         "earliestTime": {"timestamp": 2},
@@ -1429,7 +1429,7 @@ def test_edges():
                             {
                                 "page": [
                                     {
-                                        "id": ["1", "2"],
+                                        "id": [1, 2],
                                         "start": {"timestamp": 2},
                                         "end": {"timestamp": 4},
                                         "earliestTime": {"timestamp": 2},
@@ -1440,7 +1440,7 @@ def test_edges():
                             {
                                 "page": [
                                     {
-                                        "id": ["1", "2"],
+                                        "id": [1, 2],
                                         "start": {"timestamp": 2},
                                         "end": {"timestamp": 5},
                                         "earliestTime": {"timestamp": 2},
@@ -1451,7 +1451,7 @@ def test_edges():
                             {
                                 "page": [
                                     {
-                                        "id": ["1", "2"],
+                                        "id": [1, 2],
                                         "start": {"timestamp": 2},
                                         "end": {"timestamp": 6},
                                         "earliestTime": {"timestamp": 2},
@@ -1465,7 +1465,7 @@ def test_edges():
                             {
                                 "page": [
                                     {
-                                        "id": ["1", "2"],
+                                        "id": [1, 2],
                                         "start": {"timestamp": 2},
                                         "end": {"timestamp": 5},
                                         "earliestTime": {"timestamp": 2},
@@ -1476,7 +1476,7 @@ def test_edges():
                             {
                                 "page": [
                                     {
-                                        "id": ["1", "2"],
+                                        "id": [1, 2],
                                         "start": {"timestamp": 2},
                                         "end": {"timestamp": 6},
                                         "earliestTime": {"timestamp": 2},
diff --git a/python/tests/test_base_install/test_graphql/test_server_flags.py b/python/tests/test_base_install/test_graphql/test_server_flags.py
new file mode 100644
index 0000000000..1c80de56f1
--- /dev/null
+++ b/python/tests/test_base_install/test_graphql/test_server_flags.py
@@ -0,0 +1,381 @@
+import json
+import tempfile
+import urllib.error
+import urllib.request
+
+import pytest
+from raphtory import Graph
+from raphtory.graphql import GraphServer, RaphtoryClient
+
+SERVER_URL = "http://localhost:1736"
+
+
+def batch_query(body):
+    """POST a raw JSON body (needed for batch requests — the client only sends single queries)."""
+    data = json.dumps(body).encode("utf-8")
+    req = urllib.request.Request(
+        SERVER_URL + "/",
+        data=data,
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req) as resp:
+            return resp.status, json.loads(resp.read())
+    except urllib.error.HTTPError as e:
+        raw = e.read()
+        try:
+            return e.code, json.loads(raw)
+        except ValueError:
+            return e.code, raw.decode("utf-8", errors="replace")
+
+
+def make_graph(client, path="g"):
+    g = Graph()
+    g.add_edge(1, "ben", "hamza")
+    g.add_edge(2, "lucas", "hamza")
+    g.add_edge(3, "ben", "lucas")
+    client.send_graph(path, g, overwrite=True)
+
+
+def test_introspection_enabled_by_default():
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir).start():
+        client = RaphtoryClient(SERVER_URL)
+        result = client.query("{ __schema { queryType { name } } }")
+        assert result["__schema"]["queryType"]["name"]
+
+
+def test_disable_introspection():
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir, disable_introspection=True).start():
+        client = RaphtoryClient(SERVER_URL)
+        client.query("{ version }")
+
+        with pytest.raises(Exception) as excinfo:
+            client.query("{ __schema { queryType { name } } }")
+        msg = str(excinfo.value)
+        assert "Unknown field" in msg and "__schema" in msg
+
+
+def test_max_query_depth():
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir, max_query_depth=3).start():
+        client = RaphtoryClient(SERVER_URL)
+        make_graph(client)
+
+        client.query('{ graph(path: "g") { created } }')
+
+        with pytest.raises(Exception) as excinfo:
+            client.query(
+                '{ graph(path: "g") { nodes { page(limit: 5) { edges { page(limit: 5) { src { name } } } } } } }'
+            )
+        assert "Query is nested too deep." in str(excinfo.value)
+
+
+def test_max_query_complexity():
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir, max_query_complexity=3).start():
+        client = RaphtoryClient(SERVER_URL)
+        make_graph(client)
+
+        client.query("{ version }")
+
+        with pytest.raises(Exception) as excinfo:
+            client.query(
+                '{ graph(path: "g") { nodes { page(limit: 5) { name id earliestTime latestTime } } } }'
+            )
+        assert "Query is too complex." in str(excinfo.value)
+
+
+# (field path, query) pairs covering every list-returning resolver:
+# GqlCollection, GqlNodes, GqlEdges, GqlPathFromNode, GqlHistory, GqlHistoryTimestamp,
+# GqlHistoryDateTime, GqlHistoryEventId, GqlIntervals, and the six WindowSet types.
+LIST_QUERIES = [
+    ("collection (namespaces)", "{ namespaces { list { path } } }"),
+    ("GqlNodes", '{ graph(path: "g") { nodes { list { name } } } }'),
+    ("GqlNodes.ids", '{ graph(path: "g") { nodes { ids } } }'),
+    ("GqlEdges", '{ graph(path: "g") { edges { list { src { name } } } } }'),
+    (
+        "GqlPathFromNode",
+        '{ graph(path: "g") { node(name: "ben") { neighbours { list { name } } } } }',
+    ),
+    (
+        "GqlPathFromNode.ids",
+        '{ graph(path: "g") { node(name: "ben") { neighbours { ids } } } }',
+    ),
+    (
+        "GqlHistory",
+        '{ graph(path: "g") { node(name: "ben") { history { list { timestamp } } } } }',
+    ),
+    (
+        "GqlHistoryTimestamp",
+        '{ graph(path: "g") { node(name: "ben") { history { timestamps { list } } } } }',
+    ),
+    (
+        "GqlHistoryDateTime",
+        '{ graph(path: "g") { node(name: "ben") { history { datetimes { list } } } } }',
+    ),
+    (
+        "GqlHistoryEventId",
+        '{ graph(path: "g") { node(name: "ben") { history { eventId { list } } } } }',
+    ),
+    (
+        "GqlIntervals",
+        '{ graph(path: "g") { node(name: "ben") { history { intervals { list } } } } }',
+    ),
+    (
+        "GqlHistory.listRev",
+        '{ graph(path: "g") { node(name: "ben") { history { listRev { timestamp } } } } }',
+    ),
+    (
+        "GqlHistoryTimestamp.listRev",
+        '{ graph(path: "g") { node(name: "ben") { history { timestamps { listRev } } } } }',
+    ),
+    (
+        "GqlHistoryDateTime.listRev",
+        '{ graph(path: "g") { node(name: "ben") { history { datetimes { listRev } } } } }',
+    ),
+    (
+        "GqlHistoryEventId.listRev",
+        '{ graph(path: "g") { node(name: "ben") { history { eventId { listRev } } } } }',
+    ),
+    (
+        "GqlIntervals.listRev",
+        '{ graph(path: "g") { node(name: "ben") { history { intervals { listRev } } } } }',
+    ),
+    (
+        "GqlGraphWindowSet",
+        '{ graph(path: "g") { rolling(window: {epoch: 1}) { list { earliestTime { timestamp } } } } }',
+    ),
+    (
+        "GqlNodeWindowSet",
+        '{ graph(path: "g") { node(name: "ben") { rolling(window: {epoch: 1}) { list { name } } } } }',
+    ),
+    (
+        "GqlNodesWindowSet",
+        '{ graph(path: "g") { nodes { rolling(window: {epoch: 1}) { list { count } } } } }',
+    ),
+    (
+        "GqlPathFromNodeWindowSet",
+        '{ graph(path: "g") { node(name: "ben") { neighbours { rolling(window: {epoch: 1}) { list { count } } } } } }',
+    ),
+    (
+        "GqlEdgeWindowSet",
+        '{ graph(path: "g") { edge(src: "ben", dst: "hamza") { rolling(window: {epoch: 1}) { list { src { name } } } } } }',
+    ),
+    (
+        "GqlEdgesWindowSet",
+        '{ graph(path: "g") { edges { rolling(window: {epoch: 1}) { list { count } } } } }',
+    ),
+]
+
+# Same resolvers reached via `page(limit: 50)` — chosen so we can compare against a small
+# `max_page_size` limit and trigger the exceeded-size error.
+PAGE_QUERIES = [
+    ("collection (namespaces)", "{ namespaces { page(limit: 50) { path } } }"),
+    ("GqlNodes", '{ graph(path: "g") { nodes { page(limit: 50) { name } } } }'),
+    (
+        "GqlEdges",
+        '{ graph(path: "g") { edges { page(limit: 50) { src { name } } } } }',
+    ),
+    (
+        "GqlPathFromNode",
+        '{ graph(path: "g") { node(name: "ben") { neighbours { page(limit: 50) { name } } } } }',
+    ),
+    (
+        "GqlHistory",
+        '{ graph(path: "g") { node(name: "ben") { history { page(limit: 50) { timestamp } } } } }',
+    ),
+    (
+        "GqlHistoryTimestamp",
+        '{ graph(path: "g") { node(name: "ben") { history { timestamps { page(limit: 50) } } } } }',
+    ),
+    (
+        "GqlHistoryDateTime",
+        '{ graph(path: "g") { node(name: "ben") { history { datetimes { page(limit: 50) } } } } }',
+    ),
+    (
+        "GqlHistoryEventId",
+        '{ graph(path: "g") { node(name: "ben") { history { eventId { page(limit: 50) } } } } }',
+    ),
+    (
+        "GqlIntervals",
+        '{ graph(path: "g") { node(name: "ben") { history { intervals { page(limit: 50) } } } } }',
+    ),
+    (
+        "GqlHistory.pageRev",
+        '{ graph(path: "g") { node(name: "ben") { history { pageRev(limit: 50) { timestamp } } } } }',
+    ),
+    (
+        "GqlHistoryTimestamp.pageRev",
+        '{ graph(path: "g") { node(name: "ben") { history { timestamps { pageRev(limit: 50) } } } } }',
+    ),
+    (
+        "GqlHistoryDateTime.pageRev",
+        '{ graph(path: "g") { node(name: "ben") { history { datetimes { pageRev(limit: 50) } } } } }',
+    ),
+    (
+        "GqlHistoryEventId.pageRev",
+        '{ graph(path: "g") { node(name: "ben") { history { eventId { pageRev(limit: 50) } } } } }',
+    ),
+    (
+        "GqlIntervals.pageRev",
+        '{ graph(path: "g") { node(name: "ben") { history { intervals { pageRev(limit: 50) } } } } }',
+    ),
+    (
+        "GqlGraphWindowSet",
+        '{ graph(path: "g") { rolling(window: {epoch: 1}) { page(limit: 50) { earliestTime { timestamp } } } } }',
+    ),
+    (
+        "GqlNodeWindowSet",
+        '{ graph(path: "g") { node(name: "ben") { rolling(window: {epoch: 1}) { page(limit: 50) { name } } } } }',
+    ),
+    (
+        "GqlNodesWindowSet",
+        '{ graph(path: "g") { nodes { rolling(window: {epoch: 1}) { page(limit: 50) { count } } } } }',
+    ),
+    (
+        "GqlPathFromNodeWindowSet",
+        '{ graph(path: "g") { node(name: "ben") { neighbours { rolling(window: {epoch: 1}) { page(limit: 50) { count } } } } } }',
+    ),
+    (
+        "GqlEdgeWindowSet",
+        '{ graph(path: "g") { edge(src: "ben", dst: "hamza") { rolling(window: {epoch: 1}) { page(limit: 50) { src { name } } } } } }',
+    ),
+    (
+        "GqlEdgesWindowSet",
+        '{ graph(path: "g") { edges { rolling(window: {epoch: 1}) { page(limit: 50) { count } } } } }',
+    ),
+]
+
+
+def test_disable_lists_all_resolvers():
+    """Every `list` endpoint across every paginated type rejects with the same error."""
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir, disable_lists=True).start():
+        client = RaphtoryClient(SERVER_URL)
+        make_graph(client)
+
+        for name, query in LIST_QUERIES:
+            with pytest.raises(Exception) as excinfo:
+                client.query(query)
+            assert (
+                "Bulk list endpoints are disabled on this server. Use `page` instead."
+                in str(excinfo.value)
+            ), f"{name} did not reject with the expected error: {excinfo.value}"
+
+
+def test_disable_lists_page_still_works():
+    """Even with `disable_lists=True`, `page` queries still succeed."""
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir, disable_lists=True).start():
+        client = RaphtoryClient(SERVER_URL)
+        make_graph(client)
+        result = client.query(
+            '{ graph(path: "g") { nodes { page(limit: 10) { name } } } }'
+        )
+        assert len(result["graph"]["nodes"]["page"]) == 3
+
+
+def test_max_page_size_all_resolvers():
+    """Every `page` endpoint across every paginated type enforces max_page_size."""
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir, max_page_size=2).start():
+        client = RaphtoryClient(SERVER_URL)
+        make_graph(client)
+
+        for name, query in PAGE_QUERIES:
+            with pytest.raises(Exception) as excinfo:
+                client.query(query)
+            assert "page limit 50 exceeds the maximum allowed page size 2" in str(
+                excinfo.value
+            ), f"{name} did not reject with the expected error: {excinfo.value}"
+
+
+def test_max_page_size_under_cap_works():
+    """Pages at or below max_page_size still succeed."""
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir, max_page_size=2).start():
+        client = RaphtoryClient(SERVER_URL)
+        make_graph(client)
+        result = client.query(
+            '{ graph(path: "g") { nodes { page(limit: 2) { name } } } }'
+        )
+        assert len(result["graph"]["nodes"]["page"]) == 2
+
+
+def test_disable_batching():
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir, disable_batching=True).start():
+        RaphtoryClient(SERVER_URL).query("{ version }")
+
+        status, body = batch_query([{"query": "{ version }"}, {"query": "{ version }"}])
+        assert status == 400
+        assert "Query batching is disabled on this server" in str(body)
+
+
+def test_max_batch_size():
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir, max_batch_size=2).start():
+        status, body = batch_query([{"query": "{ version }"}] * 2)
+        assert status == 200
+        assert isinstance(body, list) and len(body) == 2
+
+        status, body = batch_query([{"query": "{ version }"}] * 3)
+        assert status == 400
+        assert "Batch size 3 exceeds the maximum allowed 2" in str(body)
+
+
+def test_max_recursive_depth():
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir, max_recursive_depth=2).start():
+        client = RaphtoryClient(SERVER_URL)
+        make_graph(client)
+
+        # depth 2: { graph { created } } — root selection set is depth 0, graph{...} pushes to 1
+        client.query('{ graph(path: "g") { created } }')
+
+        with pytest.raises(Exception) as excinfo:
+            client.query('{ graph(path: "g") { nodes { page(limit: 1) { name } } } }')
+        assert "recursion depth of the query cannot be greater than `2`" in str(
+            excinfo.value
+        )
+
+
+def test_max_directives_per_field():
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(work_dir, max_directives_per_field=1).start():
+        client = RaphtoryClient(SERVER_URL)
+
+        # 1 directive — allowed
+        client.query("{ version @skip(if: false) }")
+
+        # 2 directives on one field — rejected
+        with pytest.raises(Exception) as excinfo:
+            client.query("{ version @skip(if: false) @include(if: true) }")
+        assert (
+            "number of directives on the field `version` cannot be greater than `1`"
+            in str(excinfo.value)
+        )
+
+
+# heavy_query_limit and exclusive_writes are concurrency knobs. Their effects only show
+# up under parallel load (semaphore-parked queries, write/read serialization), and
+# timing-based tests are flaky in CI. This smoke test at least verifies the flags are
+# accepted and normal queries still pass through.
+def test_concurrency_flags_smoke():
+    work_dir = tempfile.mkdtemp()
+    with GraphServer(
+        work_dir,
+        heavy_query_limit=4,
+        exclusive_writes=True,
+    ).start():
+        client = RaphtoryClient(SERVER_URL)
+        make_graph(client)
+        # Read path: works under exclusive_writes's read lock.
+        assert client.query('{ graph(path: "g") { nodes { count } } }')
+        # Heavy traversal: goes through the semaphore.
+        assert client.query(
+            '{ graph(path: "g") { nodes { page(limit: 10) { neighbours { page(limit: 10) { name } } } } } }'
+        )
diff --git a/python/tests/test_base_install/test_graphql/update_graph/test_batch_updates.py b/python/tests/test_base_install/test_graphql/update_graph/test_batch_updates.py
index bc7e9b5ec4..35988b24a3 100644
--- a/python/tests/test_base_install/test_graphql/update_graph/test_batch_updates.py
+++ b/python/tests/test_base_install/test_graphql/update_graph/test_batch_updates.py
@@ -1,9 +1,8 @@
 import tempfile
 from datetime import datetime, timezone
 from typing import List
-from dateutil import parser
 from numpy.testing import assert_equal as check_arr
-from utils import assert_set_eq, assert_has_metadata
+from utils import assert_set_eq, assert_has_metadata, truncate_dt_to_ms
 from raphtory.graphql import (
     GraphServer,
     RaphtoryClient,
@@ -15,8 +14,8 @@
 
 
 def make_props():
-    current_datetime = datetime.now(timezone.utc)
-    naive_datetime = datetime.now()
+    current_datetime = truncate_dt_to_ms(datetime.now(timezone.utc))
+    naive_datetime = truncate_dt_to_ms(datetime.now())
     return {
         "prop_string": "blah",
         "prop_float": 2.0,
@@ -41,8 +40,8 @@ def make_props():
 
 
 def make_props2():
-    current_datetime = datetime.now(timezone.utc)
-    naive_datetime = datetime.now()
+    current_datetime = truncate_dt_to_ms(datetime.now(timezone.utc))
+    naive_datetime = truncate_dt_to_ms(datetime.now())
     return {
         "prop_string": "blah2",
         "prop_float": 3.0,
diff --git a/python/tests/test_base_install/test_graphql/update_graph/test_edge_updates.py b/python/tests/test_base_install/test_graphql/update_graph/test_edge_updates.py
index 731e2a6c60..f7c0181542 100644
--- a/python/tests/test_base_install/test_graphql/update_graph/test_edge_updates.py
+++ b/python/tests/test_base_install/test_graphql/update_graph/test_edge_updates.py
@@ -1,14 +1,14 @@
 import tempfile
 from datetime import datetime, timezone
 import pytest
-from utils import assert_has_metadata, assert_has_properties
+from utils import assert_has_metadata, assert_has_properties, truncate_dt_to_ms
 from raphtory.graphql import GraphServer, RaphtoryClient
 from numpy.testing import assert_equal as check_arr
 
 
 def make_props():
-    current_datetime = datetime.now(timezone.utc)
-    naive_datetime = datetime.now()
+    current_datetime = truncate_dt_to_ms(datetime.now(timezone.utc))
+    naive_datetime = truncate_dt_to_ms(datetime.now())
     return {
         "prop_string": "blah",
         "prop_float": 2.0,
@@ -33,8 +33,8 @@ def make_props():
 
 
 def make_props2():
-    current_datetime = datetime.now(timezone.utc)
-    naive_datetime = datetime.now()
+    current_datetime = truncate_dt_to_ms(datetime.now(timezone.utc))
+    naive_datetime = truncate_dt_to_ms(datetime.now())
     return {
         "prop_string": "blah2",
         "prop_float": 3.0,
@@ -95,7 +95,7 @@ def test_add_metadata():
 
         with pytest.raises(Exception) as excinfo:
             rg.edge("ben", "hamza").add_metadata({"prop_float": 3.0})
-        assert "Attempted to change value of metadata" in str(excinfo.value)
+        assert "Cannot set previous value" in str(excinfo.value)
 
 
 def test_update_metadata():
@@ -139,5 +139,5 @@ def test_delete():
         edge = rg.add_edge(1, "ben", "lucas", layer="colleagues")
         edge.delete(2, layer="colleagues")
         g = client.receive_graph("path/to/persistent_graph")
-        assert g.edge("ben", "hamza").deletions == [(2, 1)]
-        assert g.edge("ben", "lucas").deletions == [(2, 3)]
+        assert g.edge("ben", "hamza").deletions.t == [2]
+        assert g.edge("ben", "lucas").deletions.t == [2]
diff --git a/python/tests/test_base_install/test_graphql/update_graph/test_graph_updates.py b/python/tests/test_base_install/test_graphql/update_graph/test_graph_updates.py
index 36f7bdd5e9..4ca5df2c6e 100644
--- a/python/tests/test_base_install/test_graphql/update_graph/test_graph_updates.py
+++ b/python/tests/test_base_install/test_graphql/update_graph/test_graph_updates.py
@@ -4,12 +4,17 @@
 from raphtory.graphql import GraphServer, RaphtoryClient
 from datetime import datetime, timezone
 from numpy.testing import assert_equal as check_arr
-from utils import assert_set_eq, assert_has_metadata, assert_has_properties
+from utils import (
+    assert_set_eq,
+    assert_has_metadata,
+    assert_has_properties,
+    truncate_dt_to_ms,
+)
 
 
 def make_props():
-    current_datetime = datetime.now(timezone.utc)
-    naive_datetime = datetime.now()
+    current_datetime = truncate_dt_to_ms(datetime.now(timezone.utc))
+    naive_datetime = truncate_dt_to_ms(datetime.now())
     return {
         "prop_string": "blah",
         "prop_float": 2.0,
@@ -46,7 +51,7 @@ def test_add_metadata():
 
         with pytest.raises(Exception) as excinfo:
             rg.add_metadata({"prop_float": 3.0})
-        assert "Attempted to change value of metadata" in str(excinfo.value)
+        assert "Cannot set previous value" in str(excinfo.value)
 
 
 def test_update_metadata():
@@ -73,20 +78,24 @@ def test_add_properties():
         client.new_graph("path/to/event_graph", "EVENT")
         rg = client.remote_graph("path/to/event_graph")
         props = make_props()
+        # Both datetimes deliberately resolve to the same millisecond — Raphtory
+        # gives each write its own event_id, so 3 history entries should land
+        # (one at t=1 and two at the shared datetime ms). Using fixed values
+        # rather than `datetime.now()` so the test is deterministic.
+        aware_dt = datetime(2024, 1, 1, 12, 0, 0, tzinfo=timezone.utc)
+        naive_dt = datetime(2024, 1, 1, 12, 0, 0)
         rg.add_property(1, props)
-        current_datetime = datetime.now(timezone.utc)
-        naive_datetime = datetime.now()
-        rg.add_property(current_datetime, props)
-        rg.add_property(naive_datetime, props)
+        rg.add_property(aware_dt, props)
+        rg.add_property(naive_dt, props)
         g = client.receive_graph("path/to/event_graph")
         assert_has_properties(g, props)
 
-        localized_datetime = naive_datetime.replace(tzinfo=timezone.utc)
+        localized_dt = naive_dt.replace(tzinfo=timezone.utc)
         timestamps = sorted(
             [
                 1,
-                int(current_datetime.timestamp() * 1000),
-                int(localized_datetime.timestamp() * 1000),
+                int(aware_dt.timestamp() * 1000),
+                int(localized_dt.timestamp() * 1000),
             ]
         )
 
@@ -142,7 +151,7 @@ def test_delete_edge():
         rg.delete_edge(2, "ben", "hamza")
         g = client.receive_graph("path/to/event_graph")
         assert g.edge("ben", "hamza").history.t.collect() == [1]
-        assert g.edge("ben", "hamza").deletions == [(2, 1)]
+        assert g.edge("ben", "hamza").deletions.t.collect() == [2]
 
         client.new_graph("path/to/persistent_graph", "PERSISTENT")
         rg = client.remote_graph("path/to/persistent_graph")
@@ -151,5 +160,5 @@ def test_delete_edge():
         rg.add_edge(1, "ben", "lucas", layer="colleagues")
         rg.delete_edge(2, "ben", "lucas", layer="colleagues")
         g = client.receive_graph("path/to/persistent_graph")
-        assert g.edge("ben", "hamza").deletions == [(2, 1)]
-        assert g.edge("ben", "lucas").deletions == [(2, 3)]
+        assert g.edge("ben", "hamza").deletions.t.collect() == [2]
+        assert g.edge("ben", "lucas").deletions.t.collect() == [2]
diff --git a/python/tests/test_base_install/test_graphql/update_graph/test_node_updates.py b/python/tests/test_base_install/test_graphql/update_graph/test_node_updates.py
index 37ca6c0150..c394dd657d 100644
--- a/python/tests/test_base_install/test_graphql/update_graph/test_node_updates.py
+++ b/python/tests/test_base_install/test_graphql/update_graph/test_node_updates.py
@@ -3,14 +3,14 @@
 import pytest
 from dateutil import parser
 
-from utils import assert_has_properties, assert_has_metadata
+from utils import assert_has_properties, assert_has_metadata, truncate_dt_to_ms
 from raphtory.graphql import GraphServer, RaphtoryClient
 from numpy.testing import assert_equal as check_arr
 
 
 def make_props():
-    current_datetime = datetime.now(timezone.utc)
-    naive_datetime = datetime.now()
+    current_datetime = truncate_dt_to_ms(datetime.now(timezone.utc))
+    naive_datetime = truncate_dt_to_ms(datetime.now())
     return {
         "prop_string": "blah",
         "prop_float": 2.0,
@@ -79,7 +79,7 @@ def test_add_metadata():
 
         with pytest.raises(Exception) as excinfo:
             rg.node("ben").add_metadata({"prop_float": 3.0})
-        assert "Attempted to change value of metadata" in str(excinfo.value)
+        assert "Cannot set previous value" in str(excinfo.value)
 
 
 def test_update_metadata():
diff --git a/python/tests/test_base_install/test_loaders/test_load_from_pandas.py b/python/tests/test_base_install/test_loaders/test_load_from_pandas.py
index 47554b7fb7..87d838a8e6 100644
--- a/python/tests/test_base_install/test_loaders/test_load_from_pandas.py
+++ b/python/tests/test_base_install/test_loaders/test_load_from_pandas.py
@@ -272,6 +272,14 @@ def test_load_from_pandas_with_types():
         }
     )
 
+    nodes_meta_df = pd.DataFrame(
+        {
+            "id": [3, 4, 666, 6],
+            "name": ["Carol", "Dave", "Bowser", "Frank"],
+            "coins": [100, 150, 9999, 200],
+        }
+    )
+
     def assertions1(g):
         assert g.nodes.node_type == [
             "Person",
@@ -301,6 +309,19 @@ def assertions1(g):
     )
     assertions1(g)
 
+    assert g.node(666) is None
+    assert g.node(3) is not None
+    g.load_node_metadata(
+        nodes_meta_df,
+        "id",
+        metadata=["name", "coins"],
+    )
+
+    assert g.node(666) is None
+    assert g.node(3) is not None
+    assert g.node(3).metadata.get("name") == "Carol"
+    assert g.node(3).metadata.get("coins") == 100
+
     g = PersistentGraph()
     g.load_nodes(
         nodes_df,
@@ -907,7 +928,7 @@ def test_loading_list_as_properties():
         properties=["marbles"],
     )
 
-    assert g.edge(1, 2).properties["marbles"] == ["red"]
+    assert g.edge(1, 2).properties["marbles"].tolist() == ["red"]
 
     df = pd.DataFrame(
         {
@@ -925,7 +946,7 @@ def test_loading_list_as_properties():
         properties=["marbles"],
     )
 
-    assert g.node(2).properties["marbles"] == ["blue"]
+    assert g.node(2).properties["marbles"].tolist() == ["blue"]
 
 
 def test_unparsable_props():
@@ -1737,3 +1758,285 @@ def test_load_edges_csv_c_engine_time_utf8(tmp_path):
     assert {
         v.id: v.properties["time"] for v in g.nodes if "time" in v.properties
     } == expected_node_time_props
+
+
+def test_load_nodes_with_fixed_layer():
+    """load_nodes(layer=...) assigns all node updates to the named layer."""
+    nodes_df = pd.DataFrame(
+        {
+            "id": [1, 2, 3, 4, 5, 6],
+            "name": ["Alice", "Bob", "Carol", "Dave", "Eve", "Frank"],
+            "time": [1, 2, 3, 4, 5, 6],
+        }
+    )
+
+    def assertions(g):
+        assert g.unique_layers == ["node_layer"]
+        assert set(g.layers(["node_layer"]).nodes.id) == {1, 2, 3, 4, 5, 6}
+        assert dict(
+            zip(
+                g.layers(["node_layer"]).nodes.id,
+                g.layers(["node_layer"]).nodes.properties.get("name"),
+            )
+        ) == {1: "Alice", 2: "Bob", 3: "Carol", 4: "Dave", 5: "Eve", 6: "Frank"}
+
+    g = Graph()
+    g.load_nodes(
+        data=nodes_df,
+        time="time",
+        id="id",
+        properties=["name"],
+        layer="node_layer",
+    )
+    assertions(g)
+
+    g = PersistentGraph()
+    g.load_nodes(
+        data=nodes_df,
+        time="time",
+        id="id",
+        properties=["name"],
+        layer="node_layer",
+    )
+    assertions(g)
+
+
+def test_load_nodes_with_layer_col():
+    """load_nodes(layer_col=...) assigns each node update to its row's layer."""
+    nodes_df = pd.DataFrame(
+        {
+            "id": [1, 2, 3, 4, 5, 6],
+            "name": ["Alice", "Bob", "Carol", "Dave", "Eve", "Frank"],
+            "time": [1, 2, 3, 4, 5, 6],
+            "layer": ["layer A", "layer A", "layer B", "layer B", "layer C", "layer C"],
+        }
+    )
+
+    def assertions(g):
+        assert set(g.unique_layers) == {"layer A", "layer B", "layer C"}
+        assert set(g.layers(["layer A"]).nodes.id) == {1, 2}
+        assert set(g.layers(["layer B"]).nodes.id) == {3, 4}
+        assert set(g.layers(["layer C"]).nodes.id) == {5, 6}
+        assert set(g.layers(["layer A", "layer B"]).nodes.id) == {1, 2, 3, 4}
+
+    g = Graph()
+    g.load_nodes(
+        data=nodes_df,
+        time="time",
+        id="id",
+        properties=["name"],
+        layer_col="layer",
+    )
+    assertions(g)
+
+    g = PersistentGraph()
+    g.load_nodes(
+        data=nodes_df,
+        time="time",
+        id="id",
+        properties=["name"],
+        layer_col="layer",
+    )
+    assertions(g)
+
+
+def test_load_nodes_layer_and_edges_layer_combined():
+    """Nodes and edges can live in independent layers without cross-contamination."""
+    edges_df = pd.DataFrame(
+        {
+            "src": [1, 2, 3],
+            "dst": [2, 3, 4],
+            "time": [1, 2, 3],
+        }
+    )
+    nodes_df = pd.DataFrame(
+        {
+            "id": [1, 2, 3, 4],
+            "name": ["A", "B", "C", "D"],
+            "time": [1, 2, 3, 4],
+        }
+    )
+
+    def assertions(g):
+        assert set(g.unique_layers) == {"node_layer", "edge_layer"}
+        assert set(g.layers(["node_layer"]).nodes.id) == {1, 2, 3, 4}
+        assert list(g.layers(["node_layer"]).edges.id) == []
+        assert set(g.layers(["edge_layer"]).edges.id) == {(1, 2), (2, 3), (3, 4)}
+
+    g = Graph()
+    g.load_nodes(
+        data=nodes_df, time="time", id="id", properties=["name"], layer="node_layer"
+    )
+    g.load_edges(edges_df, time="time", src="src", dst="dst", layer="edge_layer")
+    assertions(g)
+
+    g = PersistentGraph()
+    g.load_nodes(
+        data=nodes_df, time="time", id="id", properties=["name"], layer="node_layer"
+    )
+    g.load_edges(edges_df, time="time", src="src", dst="dst", layer="edge_layer")
+    assertions(g)
+
+
+def test_load_nodes_invalid_layer_reference():
+    """Querying a layer that was never loaded raises an error."""
+    nodes_df = pd.DataFrame(
+        {
+            "id": [1, 2],
+            "time": [1, 2],
+        }
+    )
+    g = Graph()
+    g.load_nodes(data=nodes_df, time="time", id="id", layer="real_layer")
+
+    with pytest.raises(Exception, match="Invalid layer: nonexistent_layer"):
+        g.layers(["nonexistent_layer"])
+
+
+# --- Schema loading: Decimal & datetime PropTypes -----------------------------
+
+
+def test_load_nodes_with_decimal_schema_from_string_column():
+    """`schema={"col": PropType.decimal(N)}` casts a string column to Decimal."""
+    from decimal import Decimal
+
+    df = pd.DataFrame(
+        {
+            "id": ["s1", "s2"],
+            "time": [1, 2],
+            "price": ["19.99", "0.50"],
+        }
+    )
+    g = Graph()
+    g.load_nodes(
+        data=df,
+        id="id",
+        time="time",
+        properties=["price"],
+        schema={"price": PropType.decimal(2)},
+    )
+    assert g.node("s1").properties["price"] == Decimal("19.99")
+    assert g.node("s2").properties["price"] == Decimal("0.50")
+
+
+def test_load_nodes_with_decimal_schema_from_arrow_decimal_column():
+    """An Arrow Decimal128 column maps onto `PropType.decimal(scale)`."""
+    from decimal import Decimal
+
+    arr = pa.array(
+        [Decimal("1.23"), Decimal("4.56")],
+        type=pa.decimal128(precision=10, scale=2),
+    )
+    df = pd.DataFrame(
+        {
+            "id": ["s1", "s2"],
+            "time": [1, 2],
+            "price": arr.to_pandas(),
+        }
+    )
+    g = Graph()
+    g.load_nodes(
+        data=df,
+        id="id",
+        time="time",
+        properties=["price"],
+        schema={"price": PropType.decimal(2)},
+    )
+    assert g.node("s1").properties["price"] == Decimal("1.23")
+    assert g.node("s2").properties["price"] == Decimal("4.56")
+
+
+def test_load_edges_with_decimal_schema():
+    from decimal import Decimal
+
+    df = pd.DataFrame(
+        {
+            "src": ["a", "b"],
+            "dst": ["b", "c"],
+            "time": [1, 2],
+            "weight": ["3.14", "2.71"],
+        }
+    )
+    g = Graph()
+    g.load_edges(
+        df,
+        time="time",
+        src="src",
+        dst="dst",
+        properties=["weight"],
+        schema={"weight": PropType.decimal(2)},
+    )
+    assert g.edge("a", "b").properties["weight"] == Decimal("3.14")
+    assert g.edge("b", "c").properties["weight"] == Decimal("2.71")
+
+
+def test_load_nodes_with_naive_datetime_schema():
+    """`PropType.naive_datetime()` casts a string column to NDTime."""
+    df = pd.DataFrame(
+        {
+            "id": ["s1", "s2"],
+            "time": [1, 2],
+            "ts": ["2024-06-01T12:00:00", "2024-06-02T13:30:00"],
+        }
+    )
+    g = Graph()
+    g.load_nodes(
+        data=df,
+        id="id",
+        time="time",
+        properties=["ts"],
+        schema={"ts": PropType.naive_datetime()},
+    )
+    assert g.node("s1").properties["ts"] == datetime.datetime(2024, 6, 1, 12, 0, 0)
+    assert g.node("s2").properties["ts"] == datetime.datetime(2024, 6, 2, 13, 30, 0)
+
+
+def test_load_nodes_with_aware_datetime_schema():
+    """`PropType.datetime()` casts to DTime (timezone-aware UTC)."""
+    df = pd.DataFrame(
+        {
+            "id": ["s1", "s2"],
+            "time": [1, 2],
+            "ts": ["2024-06-01T12:00:00+00:00", "2024-06-02T13:30:00+00:00"],
+        }
+    )
+    g = Graph()
+    g.load_nodes(
+        data=df,
+        id="id",
+        time="time",
+        properties=["ts"],
+        schema={"ts": PropType.datetime()},
+    )
+    assert g.node("s1").properties["ts"] == datetime.datetime(
+        2024, 6, 1, 12, 0, 0, tzinfo=datetime.timezone.utc
+    )
+    assert g.node("s2").properties["ts"] == datetime.datetime(
+        2024, 6, 2, 13, 30, 0, tzinfo=datetime.timezone.utc
+    )
+
+
+def test_load_edges_with_datetime_schema():
+    df = pd.DataFrame(
+        {
+            "src": ["a", "b"],
+            "dst": ["b", "c"],
+            "time": [1, 2],
+            "scheduled_at": [
+                "2024-06-01T09:00:00+00:00",
+                "2024-06-02T17:00:00+00:00",
+            ],
+        }
+    )
+    g = Graph()
+    g.load_edges(
+        df,
+        time="time",
+        src="src",
+        dst="dst",
+        properties=["scheduled_at"],
+        schema={"scheduled_at": PropType.datetime()},
+    )
+    assert g.edge("a", "b").properties["scheduled_at"] == datetime.datetime(
+        2024, 6, 1, 9, 0, 0, tzinfo=datetime.timezone.utc
+    )
diff --git a/python/tests/test_base_install/test_loaders/test_load_from_parquet.py b/python/tests/test_base_install/test_loaders/test_load_from_parquet.py
index 8956ab3d61..238f0a17fa 100644
--- a/python/tests/test_base_install/test_loaders/test_load_from_parquet.py
+++ b/python/tests/test_base_install/test_loaders/test_load_from_parquet.py
@@ -1,12 +1,12 @@
 import datetime
 import os
 import re
+import tempfile
+
+import pandas as pd
 import pyarrow as pa
 import pyarrow.parquet as pq
 import pytest
-import tempfile
-import pandas as pd
-
 from raphtory import Graph, PersistentGraph
 
 
@@ -68,7 +68,11 @@ def parquet_files():
         )
     )
 
-    yield nodes_parquet_file_path, edges_parquet_file_path, edge_deletions_parquet_file_path
+    yield (
+        nodes_parquet_file_path,
+        edges_parquet_file_path,
+        edge_deletions_parquet_file_path,
+    )
 
     # Cleanup the temporary directory after tests
     dirname.cleanup()
@@ -515,7 +519,7 @@ def test_edge_both_option_failures_parquet(parquet_files):
     g = Graph()
     with pytest.raises(
         Exception,
-        match=r"Failed to load graph: You cannot set ‘layer_name’ and ‘layer_col’ at the same time. Please pick one or the other.",
+        match=r"You cannot set ‘layer_name’ and ‘layer_col’ at the same time. Please pick one or the other.",
     ):
         g.load_edges(
             edges_parquet_file_path,
@@ -528,7 +532,7 @@ def test_edge_both_option_failures_parquet(parquet_files):
 
     with pytest.raises(
         Exception,
-        match=r"Failed to load graph: You cannot set ‘layer_name’ and ‘layer_col’ at the same time. Please pick one or the other.",
+        match=r"You cannot set ‘layer_name’ and ‘layer_col’ at the same time. Please pick one or the other.",
     ):
         g.load_edge_metadata(
             edges_parquet_file_path, "src", "dst", layer="blah", layer_col="marbles"
@@ -625,7 +629,7 @@ def test_edge_both_option_failures_parquet(parquet_files):
     g = PersistentGraph()
     with pytest.raises(
         Exception,
-        match=r"Failed to load graph: You cannot set ‘layer_name’ and ‘layer_col’ at the same time. Please pick one or the other.",
+        match=r"You cannot set ‘layer_name’ and ‘layer_col’ at the same time. Please pick one or the other.",
     ):
         g.load_edges(
             edges_parquet_file_path,
@@ -638,7 +642,7 @@ def test_edge_both_option_failures_parquet(parquet_files):
 
     with pytest.raises(
         Exception,
-        match=r"Failed to load graph: You cannot set ‘layer_name’ and ‘layer_col’ at the same time. Please pick one or the other.",
+        match=r"You cannot set ‘layer_name’ and ‘layer_col’ at the same time. Please pick one or the other.",
     ):
         g.load_edge_metadata(
             edges_parquet_file_path, "src", "dst", layer="blah", layer_col="marbles"
@@ -646,7 +650,7 @@ def test_edge_both_option_failures_parquet(parquet_files):
 
     with pytest.raises(
         Exception,
-        match=r"Failed to load graph: You cannot set ‘layer_name’ and ‘layer_col’ at the same time. Please pick one or the other.",
+        match=r"You cannot set ‘layer_name’ and ‘layer_col’ at the same time. Please pick one or the other.",
     ):
         g.load_edge_deletions(
             edges_parquet_file_path,
@@ -787,7 +791,7 @@ def test_node_both_option_failures_parquet(parquet_files):
     with pytest.raises(
         Exception,
         match=re.escape(
-            r"Failed to load graph: You cannot set ‘node_type_name’ and ‘node_type_col’ at the same time. Please pick one or the other."
+            r"You cannot set ‘node_type_name’ and ‘node_type_col’ at the same time. Please pick one or the other."
         ),
     ):
         g = Graph()
@@ -802,7 +806,7 @@ def test_node_both_option_failures_parquet(parquet_files):
     with pytest.raises(
         Exception,
         match=re.escape(
-            r"Failed to load graph: You cannot set ‘node_type_name’ and ‘node_type_col’ at the same time. Please pick one or the other."
+            r"You cannot set ‘node_type_name’ and ‘node_type_col’ at the same time. Please pick one or the other."
         ),
     ):
         g = Graph()
diff --git a/python/tests/test_base_install/test_props.py b/python/tests/test_base_install/test_props.py
index 76db5d61e7..5582dd162f 100644
--- a/python/tests/test_base_install/test_props.py
+++ b/python/tests/test_base_install/test_props.py
@@ -1,6 +1,7 @@
-from raphtory import Prop
+from raphtory import Graph, Prop
 from utils import expect_unify_error, assert_in_all
 from decimal import Decimal
+from datetime import datetime, timezone
 import pytest
 
 
@@ -158,3 +159,128 @@ def test_map_with_nested_list_that_is_heterogeneous_rejected():
             }
         ).dtype()
     )
+
+
+def test_aware_datetime():
+    dt = datetime(2024, 6, 1, 12, 30, 45, tzinfo=timezone.utc)
+    p = Prop.aware_datetime(dt)
+    assert str(p.dtype()) == "DTime"
+    assert "2024-06-01" in repr(p)
+
+
+def test_aware_datetime_treats_naive_as_utc():
+    """Naive datetimes are accepted and interpreted as UTC, consistent with
+    how `EventTime` and other Raphtory time inputs handle them."""
+    naive = datetime(2024, 6, 1, 12, 30, 45)
+    aware = datetime(2024, 6, 1, 12, 30, 45, tzinfo=timezone.utc)
+    assert Prop.aware_datetime(naive) == Prop.aware_datetime(aware)
+
+
+def test_naive_datetime():
+    dt = datetime(2024, 6, 1, 12, 30, 45)
+    p = Prop.naive_datetime(dt)
+    assert str(p.dtype()) == "NDTime"
+    assert "2024-06-01" in repr(p)
+
+
+def test_decimal_from_string():
+    p = Prop.decimal("1234.5678")
+    # Decimal stores scale; dtype reports it.
+    assert str(p.dtype()) == "Decimal { scale: 4 }"
+
+
+def test_decimal_from_negative_string():
+    p = Prop.decimal("-0.001")
+    assert str(p.dtype()) == "Decimal { scale: 3 }"
+
+
+def test_decimal_from_string_zero_scale():
+    p = Prop.decimal("42")
+    assert str(p.dtype()) == "Decimal { scale: 0 }"
+
+
+def test_decimal_from_python_decimal():
+    p = Prop.decimal(Decimal("99.99"))
+    assert str(p.dtype()) == "Decimal { scale: 2 }"
+
+
+def test_decimal_from_python_decimal_high_precision():
+    """`decimal.Decimal` preserves precision regardless of float limits."""
+    p = Prop.decimal(Decimal("1.234567890123456789012345"))
+    assert str(p.dtype()) == "Decimal { scale: 24 }"
+
+
+def test_decimal_from_int():
+    p = Prop.decimal(7)
+    assert str(p.dtype()) == "Decimal { scale: 0 }"
+
+
+def test_decimal_from_negative_int():
+    p = Prop.decimal(-42)
+    assert str(p.dtype()) == "Decimal { scale: 0 }"
+
+
+def test_decimal_from_large_int():
+    p = Prop.decimal(2**62)
+    assert str(p.dtype()) == "Decimal { scale: 0 }"
+
+
+def test_decimal_from_float():
+    p = Prop.decimal(1.5)
+    assert "Decimal" in str(p.dtype())
+
+
+def test_decimal_from_negative_float():
+    p = Prop.decimal(-3.25)
+    assert "Decimal" in str(p.dtype())
+
+
+def test_decimal_rejects_non_numeric_string():
+    with pytest.raises(TypeError):
+        Prop.decimal("not a number")
+
+
+def test_decimal_rejects_unsupported_type():
+    with pytest.raises(TypeError):
+        Prop.decimal([1, 2, 3])
+
+
+def test_decimal_in_graph_roundtrips():
+    """Decimal Props attach to graph entities and are readable back."""
+    g = Graph()
+    g.add_node(1, "n", properties={"price": Prop.decimal("19.99")})
+    val = g.node("n").properties.get("price")
+    assert val == Decimal("19.99")
+
+
+def test_decimal_in_graph_from_int_then_read_back():
+    g = Graph()
+    g.add_node(1, "n", properties={"count": Prop.decimal(42)})
+    val = g.node("n").properties.get("count")
+    assert val == Decimal("42")
+
+
+def test_decimal_in_graph_from_float_then_read_back():
+    g = Graph()
+    g.add_node(1, "n", properties={"ratio": Prop.decimal(1.5)})
+    val = g.node("n").properties.get("ratio")
+    assert val == Decimal("1.5")
+
+
+def test_decimal_list_in_graph():
+    """Lists of Decimal Props inherit a unified scale."""
+    g = Graph()
+    g.add_node(
+        1,
+        "n",
+        properties={"prices": Prop.list([Prop.decimal("1.25"), Prop.decimal("2.50")])},
+    )
+    vals = g.node("n").properties.get("prices")
+    assert vals == [Decimal("1.25"), Decimal("2.50")]
+
+
+def test_decimal_list_rejects_mixed_scales():
+    """Mixing decimal scales in a list errors at unification time."""
+    expect_unify_error(
+        lambda: Prop.list([Prop.decimal("1.25"), Prop.decimal("2.5")]).dtype()
+    )
diff --git a/python/tests/test_export.py b/python/tests/test_export.py
index 181cdef376..b212606c58 100644
--- a/python/tests/test_export.py
+++ b/python/tests/test_export.py
@@ -107,7 +107,7 @@ def test_graph_timestamp_list_properties():
         ],
     )
 
-    assert g.node("a")["array_column"] == [1, 2, 3]
+    assert g.node("a")["array_column"].tolist() == [1, 2, 3]
 
     assert g.node("a")["date_column_ms"] == df["date_column_ms"][0]
     assert g.node("a")["date_column_us"] == df["date_column_us"][0]
diff --git a/python/tests/test_base_install/test_graph_benchmarks.py b/python/tests/test_graph_benchmarks.py
similarity index 100%
rename from python/tests/test_base_install/test_graph_benchmarks.py
rename to python/tests/test_graph_benchmarks.py
diff --git a/python/tests/test_permissions.py b/python/tests/test_permissions.py
new file mode 100644
index 0000000000..43488acc9d
--- /dev/null
+++ b/python/tests/test_permissions.py
@@ -0,0 +1,1735 @@
+import json
+import os
+import tempfile
+import requests
+import jwt
+import pytest
+from raphtory.graphql import GraphServer, RaphtoryClient, has_permissions_extension
+
+pytestmark = pytest.mark.skipif(
+    not has_permissions_extension(),
+    reason="raphtory-auth not compiled in (open-source build)",
+)
+
+# Reuse the same key pair as test_auth.py
+PUB_KEY = "MCowBQYDK2VwAyEADdrWr1kTLj+wSHlr45eneXmOjlHo3N1DjLIvDa2ozno="
+PRIVATE_KEY = """-----BEGIN PRIVATE KEY-----
+MC4CAQAwBQYDK2VwBCIEIFzEcSO/duEjjX4qKxDVy4uLqfmiEIA6bEw1qiPyzTQg
+-----END PRIVATE KEY-----"""
+
+RAPHTORY = "http://localhost:1736"
+
+ANALYST_JWT = jwt.encode(
+    {"access": "ro", "role": "analyst"}, PRIVATE_KEY, algorithm="EdDSA"
+)
+ANALYST_HEADERS = {"Authorization": f"Bearer {ANALYST_JWT}"}
+
+ADMIN_JWT = jwt.encode(
+    {"access": "rw", "role": "admin"}, PRIVATE_KEY, algorithm="EdDSA"
+)
+ADMIN_HEADERS = {"Authorization": f"Bearer {ADMIN_JWT}"}
+
+NO_ROLE_JWT = jwt.encode({"access": "ro"}, PRIVATE_KEY, algorithm="EdDSA")
+NO_ROLE_HEADERS = {"Authorization": f"Bearer {NO_ROLE_JWT}"}
+
+QUERY_JIRA = """query { graph(path: "jira") { path } }"""
+QUERY_ADMIN = """query { graph(path: "admin") { path } }"""
+QUERY_NS_GRAPHS = """query { root { graphs { list { path } } } }"""
+QUERY_NS_CHILDREN = """query { root { children { list { path } } } }"""
+QUERY_META_JIRA = """query { graphMetadata(path: "jira") { path nodeCount } }"""
+CREATE_JIRA = """mutation { newGraph(path:"jira", graphType:EVENT) }"""
+CREATE_ADMIN = """mutation { newGraph(path:"admin", graphType:EVENT) }"""
+CREATE_TEAM_JIRA = """mutation { newGraph(path:"team/jira", graphType:EVENT) }"""
+CREATE_TEAM_CONFLUENCE = (
+    """mutation { newGraph(path:"team/confluence", graphType:EVENT) }"""
+)
+CREATE_DEEP = """mutation { newGraph(path:"a/b/c", graphType:EVENT) }"""
+QUERY_TEAM_JIRA = """query { graph(path: "team/jira") { path } }"""
+QUERY_TEAM_GRAPHS = """query { namespace(path: "team") { graphs { list { path } } } }"""
+QUERY_A_CHILDREN = """query { namespace(path: "a") { children { list { path } } } }"""
+
+
+def gql(query: str, headers=None) -> dict:
+    h = headers if headers is not None else ADMIN_HEADERS
+    return requests.post(RAPHTORY, headers=h, data=json.dumps({"query": query})).json()
+
+
+def create_role(role: str) -> None:
+    gql(f'mutation {{ permissions {{ createRole(name: "{role}") {{ success }} }} }}')
+
+
+def grant_graph(role: str, path: str, permission: str) -> None:
+    gql(
+        f'mutation {{ permissions {{ grantGraph(role: "{role}", path: "{path}", permission: {permission}) {{ success }} }} }}'
+    )
+
+
+def grant_namespace(role: str, path: str, permission: str) -> None:
+    gql(
+        f'mutation {{ permissions {{ grantNamespace(role: "{role}", path: "{path}", permission: {permission}) {{ success }} }} }}'
+    )
+
+
+def revoke_graph(role: str, path: str) -> None:
+    gql(
+        f'mutation {{ permissions {{ revokeGraph(role: "{role}", path: "{path}") {{ success }} }} }}'
+    )
+
+
+def grant_graph_filtered_read_only(role: str, path: str, filter_gql: str) -> None:
+    """Call grantGraphFilteredReadOnly with a raw GQL filter fragment."""
+    resp = gql(
+        f'mutation {{ permissions {{ grantGraphFilteredReadOnly(role: "{role}", path: "{path}", filter: {filter_gql}) {{ success }} }} }}'
+    )
+    assert "errors" not in resp, f"grantGraphFilteredReadOnly failed: {resp}"
+
+
+def make_server(work_dir: str):
+    """Create a GraphServer wired with a permissions store at {work_dir}/permissions.json."""
+    return GraphServer(
+        work_dir,
+        auth_public_key=PUB_KEY,
+        permissions_store_path=os.path.join(work_dir, "permissions.json"),
+    )
+
+
+def test_analyst_can_access_permitted_graph():
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+        gql(CREATE_ADMIN)
+        create_role("analyst")
+        grant_graph("analyst", "jira", "READ")
+
+        response = gql(QUERY_JIRA, headers=ANALYST_HEADERS)
+        assert "errors" not in response, response
+        assert response["data"]["graph"]["path"] == "jira"
+
+
+def test_analyst_cannot_access_denied_graph():
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_ADMIN)
+        create_role("analyst")
+        grant_graph("analyst", "jira", "READ")  # only jira, not admin
+
+        # "admin" graph is silently null — analyst has no namespace INTROSPECT, so
+        # existence of "admin" is not revealed.
+        response = gql(QUERY_ADMIN, headers=ANALYST_HEADERS)
+        assert "errors" not in response, response
+        assert response["data"]["graph"] is None
+
+
+def test_admin_can_access_all_graphs():
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+        gql(CREATE_ADMIN)
+
+        for query in [QUERY_JIRA, QUERY_ADMIN]:
+            response = gql(query, headers=ADMIN_HEADERS)
+            assert "errors" not in response, response
+
+
+def test_no_role_is_denied_when_policy_is_active():
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+        create_role("analyst")
+        grant_graph("analyst", "jira", "READ")
+
+        response = gql(QUERY_JIRA, headers=NO_ROLE_HEADERS)
+        assert "errors" not in response, response
+        assert response["data"]["graph"] is None
+
+
+def test_unknown_role_is_denied_when_policy_is_active():
+    """JWT has a role claim but that role does not exist in the store → Denied.
+
+    Distinct from test_no_role_is_denied_when_policy_is_active: here the JWT
+    does carry a role claim ('analyst'), but 'analyst' was never created in the
+    store. Both paths deny, but via different branches of the policy flowchart.
+    """
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+        # Make the store non-empty with a different role — but never create "analyst"
+        create_role("other_team")
+
+        response = gql(QUERY_JIRA, headers=ANALYST_HEADERS)  # JWT says role="analyst"
+        assert "errors" not in response, response
+        assert response["data"]["graph"] is None
+
+
+def test_empty_store_denies_non_admin():
+    """With an empty permissions store (no roles configured), non-admin users are denied."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+
+        response = gql(QUERY_JIRA, headers=ANALYST_HEADERS)
+        assert "errors" not in response, response
+        assert response["data"]["graph"] is None
+
+
+def test_empty_store_allows_admin():
+    """With an empty permissions store, admin (rw JWT) still gets full access."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+
+        response = gql(QUERY_JIRA, headers=ADMIN_HEADERS)
+        assert "errors" not in response, response
+        assert response["data"]["graph"]["path"] == "jira"
+
+
+def test_introspection_allowed_with_introspect_permission():
+    """Namespace INTROSPECT makes graphs visible in listings but graph() is denied."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_TEAM_JIRA)
+        create_role("analyst")
+        grant_namespace("analyst", "team", "INTROSPECT")
+
+        # Namespace listing shows the graph as MetaGraph
+        response = gql(QUERY_TEAM_GRAPHS, headers=ANALYST_HEADERS)
+        assert "errors" not in response, response
+        paths = [g["path"] for g in response["data"]["namespace"]["graphs"]["list"]]
+        assert "team/jira" in paths
+
+        # graph() resolver returns null — INTROSPECT does not grant data access
+        response = gql(QUERY_TEAM_JIRA, headers=ANALYST_HEADERS)
+        assert "errors" not in response, response
+        assert response["data"]["graph"] is None
+
+
+def test_read_implies_introspect():
+    """READ also shows the graph in namespace listings (implies INTROSPECT)."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+        create_role("analyst")
+        grant_graph("analyst", "jira", "READ")
+
+        response = gql(QUERY_NS_GRAPHS, headers=ANALYST_HEADERS)
+        assert "errors" not in response, response
+        paths = [g["path"] for g in response["data"]["root"]["graphs"]["list"]]
+        assert "jira" in paths
+
+
+def test_permissions_update_via_mutation():
+    """Granting access via mutation takes effect immediately."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+        create_role("analyst")
+
+        # No grants yet — graph returns null (indistinguishable from "graph not found")
+        response = gql(QUERY_JIRA, headers=ANALYST_HEADERS)
+        assert "errors" not in response, response
+        assert response["data"]["graph"] is None
+
+        # Grant via mutation
+        grant_graph("analyst", "jira", "READ")
+
+        response = gql(QUERY_JIRA, headers=ANALYST_HEADERS)
+        assert "errors" not in response, response
+        assert response["data"]["graph"]["path"] == "jira"
+
+
+def test_namespace_grant_does_not_cover_root_level_graphs():
+    """Namespace grants only apply to graphs within that namespace; root-level graphs require explicit graph grants."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+        gql(CREATE_TEAM_JIRA)
+        create_role("analyst")
+        grant_namespace(
+            "analyst", "team", "READ"
+        )  # covers team/jira but not root-level jira
+
+        response = gql(QUERY_TEAM_JIRA, headers=ANALYST_HEADERS)
+        assert "errors" not in response, response
+
+        response = gql(QUERY_JIRA, headers=ANALYST_HEADERS)
+        assert "errors" not in response, response
+        assert (
+            response["data"]["graph"] is None
+        )  # root-level graph not covered by namespace grant
+
+
+# --- WRITE permission enforcement ---
+
+UPDATE_JIRA = """query { updateGraph(path: "jira") { addNode(time: 1, name: "test_node") { success } } }"""
+CREATE_JIRA_NS = """mutation { newGraph(path:"team/jira", graphType:EVENT) }"""
+
+
+def test_admin_bypasses_policy_for_reads():
+    """'access':'rw' admin can read any graph even without a role entry in the store."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+        # Policy is active (analyst role exists) but admin has no role entry
+        create_role("analyst")
+        grant_graph("analyst", "jira", "READ")
+
+        response = gql(QUERY_JIRA, headers=ADMIN_HEADERS)
+        assert "errors" not in response, response
+        assert response["data"]["graph"]["path"] == "jira"
+
+
+def test_analyst_can_write_with_write_grant():
+    """'access':'ro' user with WRITE grant on a specific graph can call updateGraph."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+        create_role("analyst")
+        grant_graph("analyst", "jira", "WRITE")
+
+        response = gql(UPDATE_JIRA, headers=ANALYST_HEADERS)
+        assert "errors" not in response, response
+
+
+def test_analyst_cannot_write_without_write_grant():
+    """'access':'ro' user with READ-only grant cannot call updateGraph."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+        create_role("analyst")
+        grant_graph("analyst", "jira", "READ")  # READ only, no WRITE
+
+        response = gql(UPDATE_JIRA, headers=ANALYST_HEADERS)
+        assert response["data"] is None or response["data"].get("updateGraph") is None
+        assert "errors" in response
+        assert "Access denied" in response["errors"][0]["message"]
+
+
+def test_analyst_can_create_graph_in_namespace():
+    """'access':'ro' user with namespace WRITE grant can create a new graph in that namespace."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        create_role("analyst")
+        grant_namespace("analyst", "team/", "WRITE")
+
+        response = gql(CREATE_JIRA_NS, headers=ANALYST_HEADERS)
+        assert "errors" not in response, response
+        assert response["data"]["newGraph"] is True
+
+
+def test_analyst_cannot_create_graph_outside_namespace():
+    """'access':'ro' user with namespace WRITE grant cannot create a graph outside that namespace."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        create_role("analyst")
+        grant_namespace("analyst", "team/", "WRITE")
+
+        response = gql(CREATE_JIRA, headers=ANALYST_HEADERS)  # "jira" not under "team/"
+        assert "errors" in response
+        assert "Access denied" in response["errors"][0]["message"]
+        # Verify "jira" was not created as a side effect
+        ns_graphs = gql(QUERY_NS_GRAPHS)["data"]["root"]["graphs"]["list"]
+        assert "jira" not in [g["path"] for g in ns_graphs]
+
+
+def test_analyst_cannot_call_permissions_mutations():
+    """'access':'ro' user with WRITE grant on a graph cannot manage roles/permissions."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        create_role("analyst")
+        grant_namespace("analyst", "team", "WRITE")
+
+        response = gql(
+            'mutation { permissions { createRole(name: "hacker") { success } } }',
+            headers=ANALYST_HEADERS,
+        )
+        assert "errors" in response
+        assert "Access denied" in response["errors"][0]["message"]
+        # Verify "hacker" role was not created as a side effect
+        roles = gql("query { permissions { listRoles } }")["data"]["permissions"][
+            "listRoles"
+        ]
+        assert "hacker" not in roles
+
+
+def test_admin_can_list_roles():
+    """'access':'rw' admin can query permissions { listRoles }."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        create_role("analyst")
+
+        response = gql("query { permissions { listRoles } }", headers=ADMIN_HEADERS)
+        assert "errors" not in response, response
+        assert "analyst" in response["data"]["permissions"]["listRoles"]
+
+
+def test_analyst_cannot_list_roles():
+    """'access':'ro' user cannot query permissions { listRoles }."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        create_role("analyst")
+
+        response = gql("query { permissions { listRoles } }", headers=ANALYST_HEADERS)
+        assert "errors" in response
+        assert "Access denied" in response["errors"][0]["message"]
+
+
+def test_admin_can_get_role():
+    """'access':'rw' admin can query permissions { getRole(...) }."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        create_role("analyst")
+        grant_graph("analyst", "jira", "READ")
+
+        response = gql(
+            'query { permissions { getRole(name: "analyst") { name graphs { path permission } } } }',
+            headers=ADMIN_HEADERS,
+        )
+        assert "errors" not in response, response
+        role_data = response["data"]["permissions"]["getRole"]
+        assert role_data["name"] == "analyst"
+        assert role_data["graphs"][0]["path"] == "jira"
+        assert role_data["graphs"][0]["permission"] == "READ"
+
+
+def test_analyst_cannot_get_role():
+    """'access':'ro' user cannot query permissions { getRole(...) }."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        create_role("analyst")
+
+        response = gql(
+            'query { permissions { getRole(name: "analyst") { name } } }',
+            headers=ANALYST_HEADERS,
+        )
+        assert "errors" in response
+        assert "Access denied" in response["errors"][0]["message"]
+
+
+def test_introspect_only_cannot_access_graph_data():
+    """Namespace INTROSPECT is denied by graph() — READ is required to access graph data."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_TEAM_JIRA)
+        create_role("analyst")
+        grant_namespace("analyst", "team", "INTROSPECT")  # no READ
+
+        response = gql(QUERY_TEAM_JIRA, headers=ANALYST_HEADERS)
+        assert "errors" not in response, response
+        assert response["data"]["graph"] is None
+
+
+def test_no_grant_hidden_from_namespace_and_graph():
+    """A role with no namespace INTROSPECT sees graph() as null, not an 'Access denied' error.
+
+    Returning an error would leak that the graph exists. Null is indistinguishable from
+    'graph not found'. An error is only appropriate when the role already has INTROSPECT
+    on the namespace (and therefore can list the graph name anyway).
+    """
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+        create_role("analyst")
+        # analyst has no grant at all
+
+        # graph() returns null silently — does not reveal the graph exists
+        response = gql(QUERY_JIRA, headers=ANALYST_HEADERS)
+        assert "errors" not in response, response
+        assert response["data"]["graph"] is None
+
+        # namespace listing hides it
+        response = gql(QUERY_NS_GRAPHS, headers=ANALYST_HEADERS)
+        assert "errors" not in response, response
+        paths = [g["path"] for g in response["data"]["root"]["graphs"]["list"]]
+        assert "jira" not in paths
+
+
+def test_grantgraph_introspect_rejected():
+    """grantGraph with INTROSPECT permission is rejected — INTROSPECT is namespace-only."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+        create_role("analyst")
+
+        response = gql(
+            'mutation { permissions { grantGraph(role: "analyst", path: "jira", permission: INTROSPECT) { success } } }'
+        )
+        assert "errors" in response
+        assert (
+            "INTROSPECT cannot be granted on a graph"
+            in response["errors"][0]["message"]
+        )
+
+
+def test_graph_metadata_allowed_with_introspect():
+    """graphMetadata is accessible with INTROSPECT permission (namespace grant)."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_TEAM_JIRA)
+        create_role("analyst")
+        grant_namespace("analyst", "team", "INTROSPECT")
+
+        response = gql(
+            'query { graphMetadata(path: "team/jira") { path nodeCount } }',
+            headers=ANALYST_HEADERS,
+        )
+        assert "errors" not in response, response
+        assert response["data"]["graphMetadata"]["path"] == "team/jira"
+
+        # graph() returns null — INTROSPECT does not grant data access
+        response = gql(QUERY_TEAM_JIRA, headers=ANALYST_HEADERS)
+        assert "errors" not in response, response
+        assert response["data"]["graph"] is None
+
+
+def test_graph_metadata_allowed_with_read():
+    """graphMetadata is also accessible with READ."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+        create_role("analyst")
+        grant_graph("analyst", "jira", "READ")
+
+        response = gql(QUERY_META_JIRA, headers=ANALYST_HEADERS)
+        assert "errors" not in response, response
+        assert response["data"]["graphMetadata"]["path"] == "jira"
+
+
+def test_graph_metadata_denied_without_grant():
+    """graphMetadata is denied when the role has no grant on the graph."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+        create_role("analyst")
+        # no grant on jira
+
+        response = gql(QUERY_META_JIRA, headers=ANALYST_HEADERS)
+        assert "errors" not in response, response
+        assert response["data"]["graphMetadata"] is None
+
+
+def test_analyst_sees_only_filtered_nodes():
+    """grantGraphFilteredReadOnly applies a node filter transparently for the role.
+
+    Admin sees all nodes; analyst only sees nodes matching the stored filter.
+    Calling grantGraph(READ) clears the filter and restores full access.
+    """
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        # Create graph and add nodes with a "region" property
+        gql(CREATE_JIRA)
+        for name, region in [
+            ("alice", "us-west"),
+            ("bob", "us-east"),
+            ("carol", "us-west"),
+        ]:
+            resp = gql(f"""query {{
+                    updateGraph(path: "jira") {{
+                        addNode(
+                            time: 1,
+                            name: "{name}",
+                            properties: [{{ key: "region", value: {{ str: "{region}" }} }}]
+                        ) {{
+                            success
+                            node {{
+                                name
+                            }}
+                        }}
+                    }}
+                }}""")
+            assert resp["data"]["updateGraph"]["addNode"]["success"] is True, resp
+
+        create_role("analyst")
+        # Grant filtered read-only: analyst only sees nodes where region = "us-west"
+        grant_graph_filtered_read_only(
+            "analyst",
+            "jira",
+            '{ node: { property: { name: "region", where: { eq: { str: "us-west" } } } } }',
+        )
+
+        QUERY_NODES = 'query { graph(path: "jira") { nodes { list { name } } } }'
+
+        # Analyst should only see alice and carol (region=us-west)
+        analyst_response = gql(QUERY_NODES, headers=ANALYST_HEADERS)
+        assert "errors" not in analyst_response, analyst_response
+        analyst_names = {
+            n["name"] for n in analyst_response["data"]["graph"]["nodes"]["list"]
+        }
+        assert analyst_names == {
+            "alice",
+            "carol",
+        }, f"expected {{alice, carol}}, got {analyst_names}"
+
+        # Admin should see all three nodes (filter is bypassed for "access":"rw")
+        admin_response = gql(QUERY_NODES, headers=ADMIN_HEADERS)
+        assert "errors" not in admin_response, admin_response
+        admin_names = {
+            n["name"] for n in admin_response["data"]["graph"]["nodes"]["list"]
+        }
+        assert admin_names == {
+            "alice",
+            "bob",
+            "carol",
+        }, f"expected all 3 nodes, got {admin_names}"
+
+        # Clear the filter by calling grantGraph(READ) — analyst should now see all nodes
+        grant_graph("analyst", "jira", "READ")
+        analyst_response_after = gql(QUERY_NODES, headers=ANALYST_HEADERS)
+        assert "errors" not in analyst_response_after, analyst_response_after
+        names_after = {
+            n["name"] for n in analyst_response_after["data"]["graph"]["nodes"]["list"]
+        }
+        assert names_after == {
+            "alice",
+            "bob",
+            "carol",
+        }, f"after plain grant, expected all 3 nodes, got {names_after}"
+
+
+def test_analyst_sees_only_filtered_edges():
+    """grantGraphFilteredReadOnly with an edge filter hides edges that don't match.
+
+    Edges with weight >= 5 are visible; edges with weight < 5 are hidden.
+    Admin bypasses the filter and sees all edges.
+    """
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+        # Add three edges: (a->b weight=3), (b->c weight=7), (a->c weight=9)
+        for src, dst, weight in [("a", "b", 3), ("b", "c", 7), ("a", "c", 9)]:
+            resp = gql(f"""query {{
+                    updateGraph(path: "jira") {{
+                        addEdge(
+                            time: 1,
+                            src: "{src}",
+                            dst: "{dst}",
+                            properties: [{{ key: "weight", value: {{ i64: {weight} }} }}]
+                        ) {{
+                            success
+                            edge {{
+                                src {{ name }}
+                                dst {{ name }}
+                            }}
+                        }}
+                    }}
+                }}""")
+            assert resp["data"]["updateGraph"]["addEdge"]["success"] is True, resp
+
+        create_role("analyst")
+        # Only show edges where weight >= 5
+        grant_graph_filtered_read_only(
+            "analyst",
+            "jira",
+            '{ edge: { property: { name: "weight", where: { ge: { i64: 5 } } } } }',
+        )
+
+        QUERY_EDGES = 'query { graph(path: "jira") { edges { list { src { name } dst { name } } } } }'
+
+        analyst_response = gql(QUERY_EDGES, headers=ANALYST_HEADERS)
+        assert "errors" not in analyst_response, analyst_response
+        analyst_edges = {
+            (e["src"]["name"], e["dst"]["name"])
+            for e in analyst_response["data"]["graph"]["edges"]["list"]
+        }
+        assert analyst_edges == {
+            ("b", "c"),
+            ("a", "c"),
+        }, f"expected only heavy edges, got {analyst_edges}"
+
+        # Admin sees all three edges
+        admin_response = gql(QUERY_EDGES, headers=ADMIN_HEADERS)
+        assert "errors" not in admin_response, admin_response
+        admin_edges = {
+            (e["src"]["name"], e["dst"]["name"])
+            for e in admin_response["data"]["graph"]["edges"]["list"]
+        }
+        assert admin_edges == {
+            ("a", "b"),
+            ("b", "c"),
+            ("a", "c"),
+        }, f"expected all edges for admin, got {admin_edges}"
+
+
+def test_raphtory_client_analyst_can_query_permitted_graph():
+    """RaphtoryClient with analyst role can query a graph it has READ access to."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+        create_role("analyst")
+        grant_graph("analyst", "jira", "READ")
+
+        client = RaphtoryClient(url=RAPHTORY, token=ANALYST_JWT)
+        result = client.query(QUERY_JIRA)
+        assert result["graph"]["path"] == "jira"
+
+
+def test_raphtory_client_analyst_denied_unpermitted_graph():
+    """RaphtoryClient with analyst role gets null for a graph it has no grant for."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+        create_role("analyst")
+        # No grant on jira — graph returns null (indistinguishable from "graph not found")
+
+        client = RaphtoryClient(url=RAPHTORY, token=ANALYST_JWT)
+        response = client.query(QUERY_JIRA)
+        assert response["graph"] is None
+
+
+def test_raphtory_client_analyst_write_with_write_grant():
+    """RaphtoryClient with analyst role and WRITE grant can add nodes via remote_graph."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+        create_role("analyst")
+        grant_graph("analyst", "jira", "WRITE")
+
+        client = RaphtoryClient(url=RAPHTORY, token=ANALYST_JWT)
+        client.remote_graph("jira").add_node(1, "client_node")
+
+        client2 = RaphtoryClient(url=RAPHTORY, token=ADMIN_JWT)
+        received = client2.receive_graph("jira")
+        assert received.node("client_node") is not None
+
+
+def test_raphtory_client_analyst_write_denied_without_write_grant():
+    """RaphtoryClient with analyst role and READ-only grant cannot add nodes via remote_graph."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+        create_role("analyst")
+        grant_graph("analyst", "jira", "READ")
+
+        client = RaphtoryClient(url=RAPHTORY, token=ANALYST_JWT)
+        with pytest.raises(Exception, match="Access denied"):
+            client.remote_graph("jira").add_node(1, "client_node")
+
+
+def test_receive_graph_requires_read():
+    """receive_graph (graph download) requires at least READ; namespace INTROSPECT is not enough."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_TEAM_JIRA)
+        create_role("analyst")
+
+        # No grant — looks like the graph doesn't exist (no information leakage)
+        client = RaphtoryClient(url=RAPHTORY, token=ANALYST_JWT)
+        with pytest.raises(Exception, match="does not exist"):
+            client.receive_graph("team/jira")
+
+        # Namespace INTROSPECT only — also denied for receive_graph, but now reveals access denied
+        grant_namespace("analyst", "team", "INTROSPECT")
+        with pytest.raises(Exception, match="Access denied"):
+            client.receive_graph("team/jira")
+
+        # READ — allowed
+        grant_namespace("analyst", "team", "READ")
+        g = client.receive_graph("team/jira")
+        assert g is not None
+
+
+def test_receive_graph_without_introspect_hides_existence():
+    """Without namespace INTROSPECT, receive_graph acts as if the graph does not exist.
+
+    This prevents information leakage: a role without any grants cannot distinguish
+    between 'graph does not exist' and 'graph exists but you are denied'.
+    """
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_TEAM_JIRA)
+        create_role("analyst")
+
+        client = RaphtoryClient(url=RAPHTORY, token=ANALYST_JWT)
+
+        # No grants at all — error must be indistinguishable from a missing graph
+        with pytest.raises(Exception, match="does not exist") as exc_no_grant:
+            client.receive_graph("team/jira")
+
+        # Compare with a truly non-existent graph — error should look the same
+        with pytest.raises(Exception, match="does not exist") as exc_missing:
+            client.receive_graph("team/nonexistent")
+
+        assert "Access denied" not in str(exc_no_grant.value)
+        assert "Access denied" not in str(exc_missing.value)
+
+
+def test_receive_graph_with_filtered_access():
+    """receive_graph with grantGraphFilteredReadOnly returns a materialized view of the filtered graph.
+
+    The downloaded graph should only contain nodes/edges that pass the stored filter,
+    not the full unfiltered graph.
+    """
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+        for name, region in [
+            ("alice", "us-west"),
+            ("bob", "us-east"),
+            ("carol", "us-west"),
+        ]:
+            resp = gql(f"""query {{
+                    updateGraph(path: "jira") {{
+                        addNode(
+                            time: 1,
+                            name: "{name}",
+                            properties: [{{ key: "region", value: {{ str: "{region}" }} }}]
+                        ) {{ success }}
+                    }}
+                }}""")
+            assert resp["data"]["updateGraph"]["addNode"]["success"] is True, resp
+
+        create_role("analyst")
+        grant_graph_filtered_read_only(
+            "analyst",
+            "jira",
+            '{ node: { property: { name: "region", where: { eq: { str: "us-west" } } } } }',
+        )
+
+        client = RaphtoryClient(url=RAPHTORY, token=ANALYST_JWT)
+        received = client.receive_graph("jira")
+
+        names = {n.name for n in received.nodes}
+        assert names == {"alice", "carol"}, f"Expected only us-west nodes, got: {names}"
+        assert "bob" not in names
+
+
+def test_analyst_sees_only_graph_filter_window():
+    """grantGraphFilteredReadOnly with a graph-level window filter restricts the temporal view.
+
+    Nodes added inside the window [5, 15) are visible; those outside are not.
+    Admin bypasses the filter and sees all nodes.
+    """
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+        # Add nodes at different timestamps: t=1 (outside), t=10 (inside), t=20 (outside)
+        for name, t in [("early", 1), ("middle", 10), ("late", 20)]:
+            resp = gql(f"""query {{
+                    updateGraph(path: "jira") {{
+                        addNode(time: {t}, name: "{name}") {{
+                            success
+                            node {{
+                                name
+                            }}
+                        }}
+                    }}
+                }}""")
+            assert resp["data"]["updateGraph"]["addNode"]["success"] is True, resp
+
+        create_role("analyst")
+        # Window [5, 15) — only "middle" (t=10) falls inside
+        grant_graph_filtered_read_only(
+            "analyst",
+            "jira",
+            "{ graph: { window: { start: 5, end: 15 } } }",
+        )
+
+        QUERY_NODES = 'query { graph(path: "jira") { nodes { list { name } } } }'
+
+        analyst_response = gql(QUERY_NODES, headers=ANALYST_HEADERS)
+        assert "errors" not in analyst_response, analyst_response
+        analyst_names = {
+            n["name"] for n in analyst_response["data"]["graph"]["nodes"]["list"]
+        }
+        assert analyst_names == {
+            "middle"
+        }, f"expected only 'middle' in window, got {analyst_names}"
+
+        # Admin sees all three nodes
+        admin_response = gql(QUERY_NODES, headers=ADMIN_HEADERS)
+        assert "errors" not in admin_response, admin_response
+        admin_names = {
+            n["name"] for n in admin_response["data"]["graph"]["nodes"]["list"]
+        }
+        assert admin_names == {
+            "early",
+            "middle",
+            "late",
+        }, f"expected all nodes for admin, got {admin_names}"
+
+
+# --- Filter composition (And / Or) tests ---
+
+
+def test_filter_and_node_node():
+    """And([node, node]): both node predicates must match (intersection)."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+        for name, region, role in [
+            ("alice", "us-west", "admin"),
+            ("bob", "us-east", "admin"),
+            ("carol", "us-west", "user"),
+        ]:
+            resp = gql(f"""query {{
+                updateGraph(path: "jira") {{
+                    addNode(
+                        time: 1, name: "{name}",
+                        properties: [
+                            {{ key: "region", value: {{ str: "{region}" }} }},
+                            {{ key: "role", value: {{ str: "{role}" }} }}
+                        ]
+                    ) {{ success }}
+                }}
+            }}""")
+            assert resp["data"]["updateGraph"]["addNode"]["success"] is True, resp
+
+        create_role("analyst")
+        # region=us-west AND role=admin → only alice
+        grant_graph_filtered_read_only(
+            "analyst",
+            "jira",
+            "{ and: ["
+            '{ node: { property: { name: "region", where: { eq: { str: "us-west" } } } } },'
+            '{ node: { property: { name: "role", where: { eq: { str: "admin" } } } } }'
+            "] }",
+        )
+
+        QUERY_NODES = 'query { graph(path: "jira") { nodes { list { name } } } }'
+        analyst_names = {
+            n["name"]
+            for n in gql(QUERY_NODES, headers=ANALYST_HEADERS)["data"]["graph"][
+                "nodes"
+            ]["list"]
+        }
+        assert analyst_names == {"alice"}, f"expected only alice, got {analyst_names}"
+
+
+def test_filter_and_edge_edge():
+    """And([edge, edge]): both edge predicates must match (intersection)."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+        for src, dst, weight, kind in [
+            ("a", "b", 3, "follows"),
+            ("b", "c", 7, "mentions"),
+            ("a", "c", 9, "follows"),
+        ]:
+            resp = gql(f"""query {{
+                updateGraph(path: "jira") {{
+                    addEdge(
+                        time: 1, src: "{src}", dst: "{dst}",
+                        properties: [
+                            {{ key: "weight", value: {{ i64: {weight} }} }},
+                            {{ key: "kind", value: {{ str: "{kind}" }} }}
+                        ]
+                    ) {{ success }}
+                }}
+            }}""")
+            assert resp["data"]["updateGraph"]["addEdge"]["success"] is True, resp
+
+        create_role("analyst")
+        # weight >= 5 AND kind=follows → only (a,c) weight=9 follows
+        grant_graph_filtered_read_only(
+            "analyst",
+            "jira",
+            "{ and: ["
+            '{ edge: { property: { name: "weight", where: { ge: { i64: 5 } } } } },'
+            '{ edge: { property: { name: "kind", where: { eq: { str: "follows" } } } } }'
+            "] }",
+        )
+
+        QUERY_EDGES = 'query { graph(path: "jira") { edges { list { src { name } dst { name } } } } }'
+        analyst_edges = {
+            (e["src"]["name"], e["dst"]["name"])
+            for e in gql(QUERY_EDGES, headers=ANALYST_HEADERS)["data"]["graph"][
+                "edges"
+            ]["list"]
+        }
+        assert analyst_edges == {
+            ("a", "c")
+        }, f"expected only (a,c), got {analyst_edges}"
+
+
+def test_filter_and_graph_graph():
+    """And([graph, graph]): two graph-level views intersect (sequential narrowing)."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+        for name, t in [("early", 1), ("middle", 10), ("late", 20)]:
+            resp = gql(f"""query {{
+                updateGraph(path: "jira") {{
+                    addNode(time: {t}, name: "{name}") {{ success }}
+                }}
+            }}""")
+            assert resp["data"]["updateGraph"]["addNode"]["success"] is True, resp
+
+        create_role("analyst")
+        # window [1,15) ∩ window [5,25) → effective [5,15) → only middle (t=10)
+        grant_graph_filtered_read_only(
+            "analyst",
+            "jira",
+            "{ and: ["
+            "{ graph: { window: { start: 1, end: 15 } } },"
+            "{ graph: { window: { start: 5, end: 25 } } }"
+            "] }",
+        )
+
+        QUERY_NODES = 'query { graph(path: "jira") { nodes { list { name } } } }'
+        analyst_names = {
+            n["name"]
+            for n in gql(QUERY_NODES, headers=ANALYST_HEADERS)["data"]["graph"][
+                "nodes"
+            ]["list"]
+        }
+        assert analyst_names == {"middle"}, f"expected only middle, got {analyst_names}"
+
+
+def test_filter_and_node_edge():
+    """And([node, edge]): node filter applied first restricts nodes (and their edges), then edge filter further restricts."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+        for name, region in [
+            ("alice", "us-west"),
+            ("bob", "us-east"),
+            ("carol", "us-west"),
+        ]:
+            resp = gql(f"""query {{
+                updateGraph(path: "jira") {{
+                    addNode(
+                        time: 1, name: "{name}",
+                        properties: [{{ key: "region", value: {{ str: "{region}" }} }}]
+                    ) {{ success }}
+                }}
+            }}""")
+            assert resp["data"]["updateGraph"]["addNode"]["success"] is True, resp
+
+        for src, dst, weight in [
+            ("alice", "bob", 3),
+            ("alice", "carol", 7),
+            ("bob", "carol", 9),
+        ]:
+            resp = gql(f"""query {{
+                updateGraph(path: "jira") {{
+                    addEdge(
+                        time: 1, src: "{src}", dst: "{dst}",
+                        properties: [{{ key: "weight", value: {{ i64: {weight} }} }}]
+                    ) {{ success }}
+                }}
+            }}""")
+            assert resp["data"]["updateGraph"]["addEdge"]["success"] is True, resp
+
+        create_role("analyst")
+        # Node(us-west) applied first: bob hidden, bob's edges hidden.
+        # Then Edge(weight≥5): of remaining edges (alice→carol weight=7), only alice→carol passes.
+        grant_graph_filtered_read_only(
+            "analyst",
+            "jira",
+            "{ and: ["
+            '{ node: { property: { name: "region", where: { eq: { str: "us-west" } } } } },'
+            '{ edge: { property: { name: "weight", where: { ge: { i64: 5 } } } } }'
+            "] }",
+        )
+
+        QUERY_NODES = 'query { graph(path: "jira") { nodes { list { name } } } }'
+        QUERY_EDGES = 'query { graph(path: "jira") { edges { list { src { name } dst { name } } } } }'
+
+        analyst_names = {
+            n["name"]
+            for n in gql(QUERY_NODES, headers=ANALYST_HEADERS)["data"]["graph"][
+                "nodes"
+            ]["list"]
+        }
+        assert analyst_names == {
+            "alice",
+            "carol",
+        }, f"expected us-west nodes, got {analyst_names}"
+
+        analyst_edges = {
+            (e["src"]["name"], e["dst"]["name"])
+            for e in gql(QUERY_EDGES, headers=ANALYST_HEADERS)["data"]["graph"][
+                "edges"
+            ]["list"]
+        }
+        # Sequential And: Node(us-west) hides bob and bob's edges, then Edge(weight≥5) keeps alice→carol (7).
+        assert analyst_edges == {
+            ("alice", "carol"),
+        }, f"expected only (alice,carol), got {analyst_edges}"
+
+
+def test_filter_and_node_graph():
+    """And([node, graph]): node property filter combined with a graph window."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+        for name, region, t in [
+            ("alice", "us-west", 1),
+            ("bob", "us-west", 10),
+            ("carol", "us-east", 10),
+        ]:
+            resp = gql(f"""query {{
+                updateGraph(path: "jira") {{
+                    addNode(
+                        time: {t}, name: "{name}",
+                        properties: [{{ key: "region", value: {{ str: "{region}" }} }}]
+                    ) {{ success }}
+                }}
+            }}""")
+            assert resp["data"]["updateGraph"]["addNode"]["success"] is True, resp
+
+        create_role("analyst")
+        # window [5,15): bob(t=10) + carol(t=10); then node us-west → only bob
+        grant_graph_filtered_read_only(
+            "analyst",
+            "jira",
+            "{ and: ["
+            "{ graph: { window: { start: 5, end: 15 } } },"
+            '{ node: { property: { name: "region", where: { eq: { str: "us-west" } } } } }'
+            "] }",
+        )
+
+        QUERY_NODES = 'query { graph(path: "jira") { nodes { list { name } } } }'
+        analyst_names = {
+            n["name"]
+            for n in gql(QUERY_NODES, headers=ANALYST_HEADERS)["data"]["graph"][
+                "nodes"
+            ]["list"]
+        }
+        assert analyst_names == {"bob"}, f"expected only bob, got {analyst_names}"
+
+
+def test_filter_and_edge_graph():
+    """And([edge, graph]): edge property filter combined with a graph window."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+        for src, dst, weight, t in [
+            ("a", "b", 3, 1),
+            ("b", "c", 7, 10),
+            ("a", "c", 9, 20),
+        ]:
+            resp = gql(f"""query {{
+                updateGraph(path: "jira") {{
+                    addEdge(
+                        time: {t}, src: "{src}", dst: "{dst}",
+                        properties: [{{ key: "weight", value: {{ i64: {weight} }} }}]
+                    ) {{ success }}
+                }}
+            }}""")
+            assert resp["data"]["updateGraph"]["addEdge"]["success"] is True, resp
+
+        create_role("analyst")
+        # window [5,15): b→c(t=10); then edge weight≥5 → b→c(weight=7) passes
+        grant_graph_filtered_read_only(
+            "analyst",
+            "jira",
+            "{ and: ["
+            "{ graph: { window: { start: 5, end: 15 } } },"
+            '{ edge: { property: { name: "weight", where: { ge: { i64: 5 } } } } }'
+            "] }",
+        )
+
+        QUERY_EDGES = 'query { graph(path: "jira") { edges { list { src { name } dst { name } } } } }'
+        analyst_edges = {
+            (e["src"]["name"], e["dst"]["name"])
+            for e in gql(QUERY_EDGES, headers=ANALYST_HEADERS)["data"]["graph"][
+                "edges"
+            ]["list"]
+        }
+        assert analyst_edges == {
+            ("b", "c")
+        }, f"expected only (b,c), got {analyst_edges}"
+
+
+def test_filter_or_node_node():
+    """Or([node, node]): nodes matching either predicate are visible (union)."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+        for name, region in [("alice", "us-west"), ("bob", "us-east"), ("carol", "eu")]:
+            resp = gql(f"""query {{
+                updateGraph(path: "jira") {{
+                    addNode(
+                        time: 1, name: "{name}",
+                        properties: [{{ key: "region", value: {{ str: "{region}" }} }}]
+                    ) {{ success }}
+                }}
+            }}""")
+            assert resp["data"]["updateGraph"]["addNode"]["success"] is True, resp
+
+        create_role("analyst")
+        # us-west OR us-east → alice + bob; carol(eu) filtered out
+        grant_graph_filtered_read_only(
+            "analyst",
+            "jira",
+            "{ or: ["
+            '{ node: { property: { name: "region", where: { eq: { str: "us-west" } } } } },'
+            '{ node: { property: { name: "region", where: { eq: { str: "us-east" } } } } }'
+            "] }",
+        )
+
+        QUERY_NODES = 'query { graph(path: "jira") { nodes { list { name } } } }'
+        analyst_names = {
+            n["name"]
+            for n in gql(QUERY_NODES, headers=ANALYST_HEADERS)["data"]["graph"][
+                "nodes"
+            ]["list"]
+        }
+        assert analyst_names == {
+            "alice",
+            "bob",
+        }, f"expected alice+bob, got {analyst_names}"
+
+
+def test_filter_or_edge_edge():
+    """Or([edge, edge]): edges matching either predicate are visible (union)."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+        for src, dst, weight in [("a", "b", 3), ("b", "c", 7), ("a", "c", 9)]:
+            resp = gql(f"""query {{
+                updateGraph(path: "jira") {{
+                    addEdge(
+                        time: 1, src: "{src}", dst: "{dst}",
+                        properties: [{{ key: "weight", value: {{ i64: {weight} }} }}]
+                    ) {{ success }}
+                }}
+            }}""")
+            assert resp["data"]["updateGraph"]["addEdge"]["success"] is True, resp
+
+        create_role("analyst")
+        # weight=3 OR weight=9 → (a,b) + (a,c); (b,c) weight=7 filtered out
+        grant_graph_filtered_read_only(
+            "analyst",
+            "jira",
+            "{ or: ["
+            '{ edge: { property: { name: "weight", where: { eq: { i64: 3 } } } } },'
+            '{ edge: { property: { name: "weight", where: { eq: { i64: 9 } } } } }'
+            "] }",
+        )
+
+        QUERY_EDGES = 'query { graph(path: "jira") { edges { list { src { name } dst { name } } } } }'
+        analyst_edges = {
+            (e["src"]["name"], e["dst"]["name"])
+            for e in gql(QUERY_EDGES, headers=ANALYST_HEADERS)["data"]["graph"][
+                "edges"
+            ]["list"]
+        }
+        assert analyst_edges == {
+            ("a", "b"),
+            ("a", "c"),
+        }, f"expected (a,b)+(a,c), got {analyst_edges}"
+
+
+# --- Namespace permission tests ---
+
+
+def test_namespace_introspect_shows_graphs_in_listing():
+    """grantNamespace INTROSPECT: graphs appear in namespace listing but graph() is denied."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_TEAM_JIRA)
+        create_role("analyst")
+        grant_namespace("analyst", "team", "INTROSPECT")
+
+        # Graphs visible as MetaGraph in namespace listing
+        response = gql(QUERY_TEAM_GRAPHS, headers=ANALYST_HEADERS)
+        assert "errors" not in response, response
+        paths = [g["path"] for g in response["data"]["namespace"]["graphs"]["list"]]
+        assert "team/jira" in paths
+
+        # Direct graph access returns null — INTROSPECT does not grant data access.
+        response = gql(QUERY_TEAM_JIRA, headers=ANALYST_HEADERS)
+        assert "errors" not in response, response
+        assert response["data"]["graph"] is None
+
+
+def test_namespace_read_exposes_graphs():
+    """grantNamespace READ: graphs in the namespace are fully accessible via graph()."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_TEAM_JIRA)
+        create_role("analyst")
+        grant_namespace("analyst", "team", "READ")
+
+        response = gql(QUERY_TEAM_JIRA, headers=ANALYST_HEADERS)
+        assert "errors" not in response, response
+        assert response["data"]["graph"]["path"] == "team/jira"
+
+
+def test_child_namespace_restriction_overrides_parent():
+    """More-specific child namespace grant overrides a broader parent grant.
+
+    team       → READ  (parent)
+    team/restricted → INTROSPECT  (child — more specific, should win)
+
+    Graphs under team/jira are reachable via READ (only parent matches).
+    Graphs under team/restricted/ are only introspectable — the child INTROSPECT
+    entry overrides the parent READ, so graph() is denied there.
+    """
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_TEAM_JIRA)
+        gql("""mutation { newGraph(path:"team/restricted/secret", graphType:EVENT) }""")
+        create_role("analyst")
+        grant_namespace("analyst", "team", "READ")
+        grant_namespace("analyst", "team/restricted", "INTROSPECT")
+
+        # team/jira: only matched by "team" → READ — direct access allowed
+        response = gql(QUERY_TEAM_JIRA, headers=ANALYST_HEADERS)
+        assert "errors" not in response, response
+        assert response["data"]["graph"]["path"] == "team/jira"
+
+        # team/restricted/secret: "team/restricted" is the most specific match → INTROSPECT only
+        response = gql(
+            """query { graph(path: "team/restricted/secret") { path } }""",
+            headers=ANALYST_HEADERS,
+        )
+        assert "errors" not in response, response
+        assert response["data"]["graph"] is None
+
+        # But team/restricted/secret should still appear in the namespace listing
+        response = gql(
+            """query { namespace(path: "team/restricted") { graphs { list { path } } } }""",
+            headers=ANALYST_HEADERS,
+        )
+        assert "errors" not in response, response
+        paths = [g["path"] for g in response["data"]["namespace"]["graphs"]["list"]]
+        assert "team/restricted/secret" in paths
+
+
+def test_discover_derivation():
+    """grantGraph READ on a namespaced graph → ancestor namespace gets DISCOVER (visible in children)."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_TEAM_JIRA)
+        create_role("analyst")
+        grant_graph("analyst", "team/jira", "READ")  # no explicit namespace grant
+
+        # "team" namespace appears in root children due to DISCOVER derivation
+        response = gql(QUERY_NS_CHILDREN, headers=ANALYST_HEADERS)
+        assert "errors" not in response, response
+        paths = [n["path"] for n in response["data"]["root"]["children"]["list"]]
+        assert "team" in paths
+
+
+def test_discover_revoked_when_only_child_revoked():
+    """Revoking the only child READ grant removes DISCOVER from the parent namespace."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_TEAM_JIRA)
+        create_role("analyst")
+        grant_graph("analyst", "team/jira", "READ")
+
+        paths = [
+            n["path"]
+            for n in gql(QUERY_NS_CHILDREN, headers=ANALYST_HEADERS)["data"]["root"][
+                "children"
+            ]["list"]
+        ]
+        assert "team" in paths  # baseline: DISCOVER present
+
+        revoke_graph("analyst", "team/jira")
+
+        paths = [
+            n["path"]
+            for n in gql(QUERY_NS_CHILDREN, headers=ANALYST_HEADERS)["data"]["root"][
+                "children"
+            ]["list"]
+        ]
+        assert "team" not in paths  # DISCOVER gone
+
+
+def test_discover_stays_when_one_of_two_children_revoked():
+    """DISCOVER persists while at least one child grant remains; clears only when all are revoked."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_TEAM_JIRA)
+        gql(CREATE_TEAM_CONFLUENCE)
+        create_role("analyst")
+        grant_graph("analyst", "team/jira", "READ")
+        grant_graph("analyst", "team/confluence", "READ")
+
+        revoke_graph("analyst", "team/jira")
+        paths = [
+            n["path"]
+            for n in gql(QUERY_NS_CHILDREN, headers=ANALYST_HEADERS)["data"]["root"][
+                "children"
+            ]["list"]
+        ]
+        assert "team" in paths  # still visible via team/confluence
+
+        revoke_graph("analyst", "team/confluence")
+        paths = [
+            n["path"]
+            for n in gql(QUERY_NS_CHILDREN, headers=ANALYST_HEADERS)["data"]["root"][
+                "children"
+            ]["list"]
+        ]
+        assert "team" not in paths  # now gone
+
+
+def test_discover_stays_when_parent_has_explicit_namespace_read():
+    """Revoking a child graph READ does not remove an explicit namespace READ on the parent."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_TEAM_JIRA)
+        create_role("analyst")
+        grant_graph("analyst", "team/jira", "READ")
+        grant_namespace("analyst", "team", "READ")  # explicit, higher than DISCOVER
+
+        revoke_graph("analyst", "team/jira")
+
+        paths = [
+            n["path"]
+            for n in gql(QUERY_NS_CHILDREN, headers=ANALYST_HEADERS)["data"]["root"][
+                "children"
+            ]["list"]
+        ]
+        assert "team" in paths  # still visible via explicit namespace READ
+
+
+def test_discover_revoked_for_nested_namespaces():
+    """Revoking the only deep grant removes DISCOVER from all ancestor namespaces."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_DEEP)
+        create_role("analyst")
+        grant_graph("analyst", "a/b/c", "READ")  # "a" and "a/b" both get DISCOVER
+
+        root_paths = [
+            n["path"]
+            for n in gql(QUERY_NS_CHILDREN, headers=ANALYST_HEADERS)["data"]["root"][
+                "children"
+            ]["list"]
+        ]
+        assert "a" in root_paths
+
+        a_paths = [
+            n["path"]
+            for n in gql(QUERY_A_CHILDREN, headers=ANALYST_HEADERS)["data"][
+                "namespace"
+            ]["children"]["list"]
+        ]
+        assert "a/b" in a_paths
+
+        revoke_graph("analyst", "a/b/c")
+
+        root_paths = [
+            n["path"]
+            for n in gql(QUERY_NS_CHILDREN, headers=ANALYST_HEADERS)["data"]["root"][
+                "children"
+            ]["list"]
+        ]
+        assert "a" not in root_paths
+
+        a_paths = [
+            n["path"]
+            for n in gql(QUERY_A_CHILDREN, headers=ANALYST_HEADERS)["data"][
+                "namespace"
+            ]["children"]["list"]
+        ]
+        assert "a/b" not in a_paths
+
+
+def test_no_namespace_grant_hidden_from_children():
+    """No grants at all → namespace is hidden from root children listing."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_TEAM_JIRA)
+        create_role("analyst")
+        # analyst has no grants at all
+
+        response = gql(QUERY_NS_CHILDREN, headers=ANALYST_HEADERS)
+        assert "errors" not in response, response
+        paths = [n["path"] for n in response["data"]["root"]["children"]["list"]]
+        assert "team" not in paths
+
+
+# --- deleteGraph / sendGraph policy delegation ---
+
+DELETE_JIRA = """mutation { deleteGraph(path: "jira") }"""
+DELETE_TEAM_JIRA = """mutation { deleteGraph(path: "team/jira") }"""
+
+
+def test_analyst_can_delete_with_graph_and_namespace_write():
+    """deleteGraph requires WRITE on both the graph and its parent namespace."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_TEAM_JIRA)
+        create_role("analyst")
+        grant_graph("analyst", "team/jira", "WRITE")
+        grant_namespace("analyst", "team", "WRITE")
+
+        response = gql(DELETE_TEAM_JIRA, headers=ANALYST_HEADERS)
+        assert "errors" not in response, response
+        assert response["data"]["deleteGraph"] is True
+
+
+def test_analyst_cannot_delete_with_graph_write_only():
+    """Graph WRITE alone is insufficient for deleteGraph — namespace WRITE is also required."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+        create_role("analyst")
+        grant_graph("analyst", "jira", "WRITE")
+
+        response = gql(DELETE_JIRA, headers=ANALYST_HEADERS)
+        assert "errors" in response
+        assert "Access denied" in response["errors"][0]["message"]
+        # Verify "jira" was not deleted as a side effect
+        check = gql(QUERY_JIRA)
+        assert check["data"]["graph"]["path"] == "jira"
+
+
+def test_analyst_cannot_delete_with_read_grant():
+    """'access':'ro' user with READ-only grant is denied by deleteGraph."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+        create_role("analyst")
+        grant_graph("analyst", "jira", "READ")
+
+        response = gql(DELETE_JIRA, headers=ANALYST_HEADERS)
+        assert "errors" in response
+        assert "Access denied" in response["errors"][0]["message"]
+        # Verify "jira" was not deleted as a side effect
+        check = gql(QUERY_JIRA)
+        assert check["data"]["graph"]["path"] == "jira"
+
+
+def test_analyst_can_delete_with_namespace_write():
+    """'access':'ro' user with namespace WRITE (cascades to graph WRITE) can delete a graph."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_TEAM_JIRA)
+        create_role("analyst")
+        grant_namespace("analyst", "team", "WRITE")
+
+        response = gql(DELETE_TEAM_JIRA, headers=ANALYST_HEADERS)
+        assert "errors" not in response, response
+        assert response["data"]["deleteGraph"] is True
+
+
+def test_analyst_cannot_send_graph_without_namespace_write():
+    """'access':'ro' user without namespace WRITE is denied by sendGraph."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        create_role("analyst")
+        grant_namespace("analyst", "team", "READ")  # READ, not WRITE
+
+        response = gql(
+            'mutation { sendGraph(path: "team/new", graph: "dummydata", overwrite: false) }',
+            headers=ANALYST_HEADERS,
+        )
+        assert "errors" in response
+        assert "Access denied" in response["errors"][0]["message"]
+
+
+def test_analyst_send_graph_passes_auth_with_namespace_write():
+    """'access':'ro' user with namespace WRITE passes the auth gate in sendGraph.
+
+    The request fails on graph decoding (invalid data), not on access control —
+    proving the namespace WRITE check is honoured.
+    """
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        create_role("analyst")
+        grant_namespace("analyst", "team", "WRITE")
+
+        response = gql(
+            'mutation { sendGraph(path: "team/new", graph: "not_valid_base64", overwrite: false) }',
+            headers=ANALYST_HEADERS,
+        )
+        # Auth passed — error is about graph decoding, not access
+        assert "errors" in response
+        assert "Access denied" not in response["errors"][0]["message"]
+
+
+def test_analyst_send_graph_valid_data_with_namespace_write():
+    """'access':'ro' user with namespace WRITE can successfully send a valid graph via sendGraph.
+
+    Admin creates a graph and downloads it; analyst with WRITE sends it to a new path.
+    The graph appears at the new path and its data matches the original.
+    """
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+        # Add a node so the graph has content to verify after the roundtrip
+        gql("""query {
+                updateGraph(path: "jira") {
+                    addNode(time: 1, name: "alice", properties: []) { success }
+                }
+            }""")
+
+        # Admin downloads the graph as valid base64
+        encoded = gql('query { receiveGraph(path: "jira") }')["data"]["receiveGraph"]
+
+        create_role("analyst")
+        grant_namespace("analyst", "team", "WRITE")
+
+        # Analyst sends the encoded graph to a new path
+        response = gql(
+            f'mutation {{ sendGraph(path: "team/copy", graph: "{encoded}", overwrite: false) }}',
+            headers=ANALYST_HEADERS,
+        )
+        assert "errors" not in response, response
+        assert response["data"]["sendGraph"] == "team/copy"
+
+        # Verify the copy exists and contains the expected node
+        check = gql('query { graph(path: "team/copy") { nodes { list { name } } } }')
+        names = [n["name"] for n in check["data"]["graph"]["nodes"]["list"]]
+        assert "alice" in names
+
+
+# --- moveGraph policy ---
+
+MOVE_TEAM_JIRA = """mutation { moveGraph(path: "team/jira", newPath: "team/jira-moved", overwrite: false) }"""
+
+
+def test_analyst_can_move_with_graph_write_and_namespace_write():
+    """moveGraph requires WRITE on the source graph and its parent namespace, plus WRITE on the destination namespace."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_TEAM_JIRA)
+        create_role("analyst")
+        grant_graph("analyst", "team/jira", "WRITE")
+        grant_namespace("analyst", "team", "WRITE")
+
+        response = gql(MOVE_TEAM_JIRA, headers=ANALYST_HEADERS)
+        assert "errors" not in response, response
+        assert response["data"]["moveGraph"] is True
+
+
+def test_analyst_cannot_move_with_graph_write_only():
+    """Graph WRITE alone is insufficient for moveGraph — namespace WRITE on source is also required."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_TEAM_JIRA)
+        create_role("analyst")
+        grant_graph("analyst", "team/jira", "WRITE")
+        # no namespace grant → namespace WRITE check fails
+
+        response = gql(MOVE_TEAM_JIRA, headers=ANALYST_HEADERS)
+        assert "errors" in response
+        assert "Access denied" in response["errors"][0]["message"]
+        # Verify "team/jira" still exists and "team/jira-moved" was not created
+        team_graphs = gql(QUERY_TEAM_GRAPHS)["data"]["namespace"]["graphs"]["list"]
+        paths = [g["path"] for g in team_graphs]
+        assert "team/jira" in paths
+        assert "team/jira-moved" not in paths
+
+
+def test_analyst_cannot_move_with_read_grant():
+    """READ on source graph is insufficient for moveGraph — WRITE is required."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_TEAM_JIRA)
+        create_role("analyst")
+        grant_graph("analyst", "team/jira", "READ")
+        grant_namespace("analyst", "team", "WRITE")
+
+        response = gql(MOVE_TEAM_JIRA, headers=ANALYST_HEADERS)
+        assert "errors" in response
+        assert "Access denied" in response["errors"][0]["message"]
+        # Verify "team/jira" still exists and "team/jira-moved" was not created
+        team_graphs = gql(QUERY_TEAM_GRAPHS)["data"]["namespace"]["graphs"]["list"]
+        paths = [g["path"] for g in team_graphs]
+        assert "team/jira" in paths
+        assert "team/jira-moved" not in paths
+
+
+# --- newGraph namespace write enforcement ---
+
+
+def test_analyst_can_create_namespaced_graph_with_namespace_write():
+    """'access':'ro' user with namespace WRITE can create a graph inside that namespace."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        create_role("analyst")
+        grant_namespace("analyst", "team", "WRITE")
+
+        response = gql(CREATE_TEAM_JIRA, headers=ANALYST_HEADERS)
+        assert "errors" not in response, response
+        assert response["data"]["newGraph"] is True
+
+
+def test_analyst_cannot_create_graph_with_namespace_read_only():
+    """'access':'ro' user with namespace READ (not WRITE) is denied by newGraph."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        create_role("analyst")
+        grant_namespace("analyst", "team", "READ")
+
+        response = gql(CREATE_TEAM_JIRA, headers=ANALYST_HEADERS)
+        assert "errors" in response
+        assert "Access denied" in response["errors"][0]["message"]
+        # Verify "team/jira" was not created as a side effect — "team" namespace should be absent
+        children = gql(QUERY_NS_CHILDREN)["data"]["root"]["children"]["list"]
+        assert "team" not in [c["path"] for c in children]
+
+
+# --- permissions entry point admin gate ---
+
+
+def test_analyst_cannot_access_permissions_query_entry_point():
+    """'access':'ro' user is denied at the permissions query entry point, not just the individual ops.
+
+    This verifies the entry-point-level admin check added to query { permissions { ... } }.
+    Even with full namespace WRITE, a non-admin JWT cannot reach the permissions resolver.
+    """
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        create_role("analyst")
+        grant_namespace("analyst", "team", "WRITE")  # full write, still not admin
+
+        response = gql(
+            "query { permissions { listRoles } }",
+            headers=ANALYST_HEADERS,
+        )
+        assert "errors" in response
+        assert "Access denied" in response["errors"][0]["message"]
+
+
+def test_analyst_cannot_access_permissions_mutation_entry_point():
+    """'access':'ro' user is denied at the mutation { permissions { ... } } entry point.
+
+    Even with full namespace WRITE, a non-admin JWT is blocked before reaching any op.
+    """
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        create_role("analyst")
+        grant_namespace("analyst", "team", "WRITE")  # full write, still not admin
+
+        response = gql(
+            'mutation { permissions { createRole(name: "hacker") { success } } }',
+            headers=ANALYST_HEADERS,
+        )
+        assert "errors" in response
+        assert "Access denied" in response["errors"][0]["message"]
+
+
+# --- createIndex policy ---
+
+
+def test_analyst_can_create_index_with_graph_write():
+    """A user with WRITE on a graph can call createIndex (not admin-only)."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+        create_role("analyst")
+        grant_graph("analyst", "jira", "WRITE")
+
+        response = gql(
+            'mutation { createIndex(path: "jira", inRam: true) }',
+            headers=ANALYST_HEADERS,
+        )
+        # Auth passed — success or a feature-not-compiled error, not an access denial
+        if "errors" in response:
+            assert "Access denied" not in response["errors"][0]["message"]
+
+
+def test_analyst_cannot_create_index_with_read_grant():
+    """READ on a graph is insufficient for createIndex — WRITE is required."""
+    work_dir = tempfile.mkdtemp()
+    with make_server(work_dir).start():
+        gql(CREATE_JIRA)
+        create_role("analyst")
+        grant_graph("analyst", "jira", "READ")
+
+        response = gql(
+            'mutation { createIndex(path: "jira", inRam: true) }',
+            headers=ANALYST_HEADERS,
+        )
+        assert "errors" in response
+        assert "Access denied" in response["errors"][0]["message"]
diff --git a/python/tests/test_base_install/test_graphql/test_gql_index_spec.py b/python/tests/test_search/test_gql_index_spec.py
similarity index 100%
rename from python/tests/test_base_install/test_graphql/test_gql_index_spec.py
rename to python/tests/test_search/test_gql_index_spec.py
diff --git a/python/tests/test_base_install/test_index.py b/python/tests/test_search/test_index.py
similarity index 100%
rename from python/tests/test_base_install/test_index.py
rename to python/tests/test_search/test_index.py
diff --git a/python/tests/test_base_install/test_index_spec.py b/python/tests/test_search/test_index_spec.py
similarity index 100%
rename from python/tests/test_base_install/test_index_spec.py
rename to python/tests/test_search/test_index_spec.py
diff --git a/python/tests/test_base_install/test_graphql/misc/test_graphql_vectors.py b/python/tests/test_vectors/test_graphql_vectors.py
similarity index 60%
rename from python/tests/test_base_install/test_graphql/misc/test_graphql_vectors.py
rename to python/tests/test_vectors/test_graphql_vectors.py
index b0aa5fdd43..6a22c0b35c 100644
--- a/python/tests/test_base_install/test_graphql/misc/test_graphql_vectors.py
+++ b/python/tests/test_vectors/test_graphql_vectors.py
@@ -94,6 +94,57 @@ def test_upload_graph():
             assert_correct_documents(client)
 
 
+def test_vectorised_graph_window_accepts_time_input_shapes():
+    """`VectorisedGraphWindow.{start, end}` accepts every `TimeInput` shape —
+    Int, RFC3339 string, and `{timestamp, eventId}` object.
+
+    Verifies the schema accepts each form and that all three forms produce
+    the *same* result for the same time bounds (i.e. they're parsed
+    equivalently)."""
+    work_dir = tempfile.TemporaryDirectory()
+    server = GraphServer(work_dir.name)
+    with embeddings.start(7340):
+        with server.start():
+            client = RaphtoryClient("http://localhost:1736")
+            client.new_graph("abb", "EVENT")
+            rg = client.remote_graph("abb")
+            setup_graph(rg)
+            # `model` and `apiBase` point at the mock embedding server above,
+            # so the model name is just a placeholder identifier.
+            client.query("""
+                {
+                    vectoriseGraph(path: "abb", model: { openAI: { model: "mock-model", apiBase: "http://localhost:7340" } }, nodes: { custom: "{{ name }}" }, edges: { enabled: false })
+                }
+                """)
+
+            def run(window_literal: str):
+                q = """
+                    {
+                        vectorisedGraph(path: "abb") {
+                            entitiesBySimilarity(query: "aab", limit: 5, window: %s) {
+                                getDocuments { entity { ... on Node { name } } }
+                            }
+                        }
+                    }
+                    """ % window_literal
+                return client.query(q)
+
+            # Same time bounds, three different input shapes — all should be
+            # accepted by the schema and produce identical results.
+            int_form = run("{ start: 0, end: 1000 }")
+            str_form = run(
+                '{ start: "1970-01-01T00:00:00.000Z", end: "1970-01-01T00:00:01.000Z" }'
+            )
+            obj_form = run(
+                "{ start: {timestamp: 0, eventId: 0}, end: {timestamp: 1000, eventId: 0} }"
+            )
+
+            assert int_form == str_form == obj_form, (
+                "All three TimeInput shapes should produce identical results "
+                f"for equivalent time bounds.\nint:  {int_form}\nstr:  {str_form}\nobj:  {obj_form}"
+            )
+
+
 GRAPH_NAME = "abb"
 
 
diff --git a/python/tests/test_base_install/test_vectors.py b/python/tests/test_vectors/test_vectors.py
similarity index 100%
rename from python/tests/test_base_install/test_vectors.py
rename to python/tests/test_vectors/test_vectors.py
diff --git a/python/tox.ini b/python/tox.ini
index 8117a83f30..a0b42869dd 100644
--- a/python/tox.ini
+++ b/python/tox.ini
@@ -1,7 +1,7 @@
 [tox]
 requires =
     tox>=4
-env_list = base, export, all, examples, docs
+env_list = base, export, benchmark, examples, docs, auth, timezone
 
 # MATURIN_PEP517_ARGS
 [testenv]
@@ -10,21 +10,42 @@ package = wheel
 wheel_build_env = .pkg
 extras =
     tox
-    all, storage: test
+    all, storage, auth, timezone, permissions: test
     export: export
-    all, storage: all
+    all: all
 pass_env =
     DISK_TEST_MARK
 
 [testenv:.pkg]
 pass_env = MATURIN_PEP517_ARGS
 
+[testenv:search]
+wheel_build_env = .pkg_search
+commands = pytest {tty:--color=yes} tests/test_search
+
+[testenv:.pkg_search]
+set_env =
+    MATURIN_PEP517_ARGS="--features=search,extension-module"
+
+
 [testenv:export]
-commands = pytest --nbmake --nbmake-timeout=1200 {tty:--color=yes} tests/test_export.py
+commands = pytest {tty:--color=yes} tests/test_export.py
+
+[testenv:timezone]
+commands = pytest {tty:--color=yes} tests/test_timezone.py
 
 [testenv:base]
 commands = pytest --nbmake --nbmake-timeout=1200 {tty:--color=yes} tests/test_base_install
 
+[testenv:auth]
+commands = pytest tests/test_auth.py
+
+[testenv:permissions]
+commands = pytest tests/test_permissions.py
+
+[testenv:vectors]
+commands = pytest tests/test_vectors
+
 [testenv:all]
 commands = pytest --nbmake --nbmake-timeout=1200 {tty:--color=yes} tests
 
@@ -34,15 +55,8 @@ deps =
     matplotlib
 commands = pytest --nbmake --nbmake-timeout=1200 {tty:--color=yes} ../examples/python/socio-patterns/example.ipynb
 
-[testenv:storage]
-set_env =
-    DISK_TEST_MARK=1
-wheel_build_env = .pkg_private
-commands = pytest --nbmake --nbmake-timeout=1200 {tty:--color=yes} tests
-
-[testenv:.pkg_private]
-set_env =
-    MATURIN_PEP517_ARGS="--features=storage,extension-module"
+[testenv:benchmark]
+commands = pytest tests/test_graph_benchmarks.py
 
 [testenv:docs]
 deps =
diff --git a/raphtory-api-macros/Cargo.toml b/raphtory-api-macros/Cargo.toml
new file mode 100644
index 0000000000..1d2df24aa0
--- /dev/null
+++ b/raphtory-api-macros/Cargo.toml
@@ -0,0 +1,20 @@
+[package]
+name = "raphtory-api-macros"
+version.workspace = true
+documentation.workspace = true
+repository.workspace = true
+license.workspace = true
+readme.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+authors.workspace = true
+rust-version.workspace = true
+edition.workspace = true
+
+[lib]
+proc-macro = true
+
+[dependencies]
+proc-macro2 = "1.0"
+quote = "1.0"
+syn = { version = "2.0", features = ["full"] }
diff --git a/raphtory-api-macros/build.rs b/raphtory-api-macros/build.rs
new file mode 100644
index 0000000000..33154a7c92
--- /dev/null
+++ b/raphtory-api-macros/build.rs
@@ -0,0 +1,11 @@
+use std::io::Result;
+fn main() -> Result<()> {
+    println!("cargo::rustc-check-cfg=cfg(has_debug_symbols)");
+
+    if let Ok(profile) = std::env::var("PROFILE") {
+        if profile.contains("debug") {
+            println!("cargo::rustc-cfg=has_debug_symbols");
+        }
+    }
+    Ok(())
+}
diff --git a/raphtory-api-macros/src/lib.rs b/raphtory-api-macros/src/lib.rs
new file mode 100644
index 0000000000..aaa289882f
--- /dev/null
+++ b/raphtory-api-macros/src/lib.rs
@@ -0,0 +1,217 @@
+use proc_macro::TokenStream;
+use proc_macro2::TokenStream as TokenStream2;
+use quote::{quote, ToTokens};
+use syn::{parse_macro_input, Error, ItemFn, Path, Result, ReturnType, Type, TypeParamBound};
+
+/// A specialized procedural macro for functions with complex lifetime parameters.
+/// This macro handles functions that have explicit lifetime parameters and complex bounds.
+///
+/// # Usage
+///
+/// Simply annotate your iterator-returning function with `#[box_on_debug_lifetime]`:
+///
+/// ## Method with complex lifetime bounds:
+/// ```rust
+/// use raphtory_api_macros::box_on_debug_lifetime;
+///
+/// struct Graph;
+/// struct LayerIds;
+/// struct EntryRef<'a>(&'a str);
+///
+/// impl Graph {
+///     #[box_on_debug_lifetime]
+///     fn edge_iter<'a, 'b: 'a>(
+///         &'a self,
+///         layer_ids: &'b LayerIds,
+///     ) -> impl Iterator<Item = EntryRef<'a>> + Send + Sync + 'a {
+///         std::iter::once(EntryRef("test"))
+///     }
+/// }
+///
+/// // Test the method works
+/// let graph = Graph;
+/// let layer_ids = LayerIds;
+/// let entries: Vec<EntryRef> = graph.edge_iter(&layer_ids).collect();
+/// assert_eq!(entries.len(), 1);
+/// assert_eq!(entries[0].0, "test");
+/// ```
+///
+/// ## Function consuming self with lifetime parameter:
+/// ```rust
+/// use raphtory_api_macros::box_on_debug_lifetime;
+///
+/// struct EdgeStorage;
+/// struct LayerIds;
+/// struct EdgeStorageEntry<'a>(&'a str);
+///
+/// impl EdgeStorage {
+///     #[box_on_debug_lifetime]
+///     pub fn iter<'a>(self, layer_ids: &'a LayerIds) -> impl Iterator<Item = EdgeStorageEntry<'a>> + 'a {
+///         std::iter::once(EdgeStorageEntry("test"))
+///     }
+/// }
+///
+/// // Test the function works
+/// let storage = EdgeStorage;
+/// let layer_ids = LayerIds;
+/// let entries: Vec<EdgeStorageEntry> = storage.iter(&layer_ids).collect();
+/// assert_eq!(entries.len(), 1);
+/// assert_eq!(entries[0].0, "test");
+/// ```
+///
+/// ## Function with where clause:
+/// ```rust
+/// use raphtory_api_macros::box_on_debug_lifetime;
+///
+/// struct Data<T> {
+///     items: Vec<T>,
+/// }
+///
+/// impl<T> Data<T>
+/// where
+///     T: Clone + Send + Sync,
+/// {
+///     #[box_on_debug_lifetime]
+///     pub fn iter_cloned<'a>(&'a self) -> impl Iterator<Item = T> + 'a
+///     where
+///         T: Clone,
+///     {
+///         self.items.iter().cloned()
+///     }
+/// }
+///
+/// // Test the function works
+/// let data = Data { items: vec![1, 2, 3, 4, 5] };
+/// let cloned: Vec<i32> = data.iter_cloned().collect();
+/// assert_eq!(cloned, vec![1, 2, 3, 4, 5]);
+/// ```
+///
+#[proc_macro_attribute]
+pub fn box_on_debug_lifetime(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    let input_fn = parse_macro_input!(item as ItemFn);
+
+    match generate_box_on_debug_lifetime_impl(&input_fn) {
+        Ok(output) => output.into(),
+        Err(err) => err.to_compile_error().into(),
+    }
+}
+
+fn generate_box_on_debug_lifetime_impl(input_fn: &ItemFn) -> Result<TokenStream2> {
+    let attrs = &input_fn.attrs;
+    let vis = &input_fn.vis;
+    let sig = &input_fn.sig;
+    let block = &input_fn.block;
+    let fn_name = &sig.ident;
+
+    // Parse the return type to extract iterator information
+    let (item_type, bounds) = parse_iterator_return_type(&sig.output)?;
+
+    // For lifetime version, we preserve all bounds including lifetimes
+    let debug_return_type = generate_boxed_return_type_with_lifetimes(&item_type, &bounds);
+
+    // Generate the release version (original)
+    let release_return_type = &sig.output;
+
+    let generics = &sig.generics;
+    let inputs = &sig.inputs;
+    let where_clause = &sig.generics.where_clause;
+
+    Ok(quote! {
+        #[cfg(has_debug_symbols)]
+        #(#attrs)*
+        #vis fn #fn_name #generics(#inputs) #debug_return_type #where_clause {
+            let iter = #block;
+            Box::new(iter)
+        }
+
+        #[cfg(not(has_debug_symbols))]
+        #(#attrs)*
+        #vis fn #fn_name #generics(#inputs) #release_return_type #where_clause {
+            #block
+        }
+    })
+}
+
+fn parse_iterator_return_type(
+    return_type: &ReturnType,
+) -> Result<(TokenStream2, Vec<TokenStream2>)> {
+    match return_type {
+        ReturnType::Type(_, ty) => {
+            if let Type::ImplTrait(impl_trait) = ty.as_ref() {
+                let mut item_type = None;
+                let mut bounds = Vec::new();
+
+                for bound in &impl_trait.bounds {
+                    match bound {
+                        TypeParamBound::Trait(trait_bound) => {
+                            let path = &trait_bound.path;
+
+                            // Check if this is an Iterator trait
+                            if is_iterator_trait(path) {
+                                // Extract the Item type from Iterator<Item = ...>
+                                if let Some(seg) = path.segments.last() {
+                                    if let syn::PathArguments::AngleBracketed(args) = &seg.arguments
+                                    {
+                                        for arg in &args.args {
+                                            if let syn::GenericArgument::AssocType(binding) = arg {
+                                                if binding.ident == "Item" {
+                                                    item_type = Some(binding.ty.to_token_stream());
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            } else {
+                                // This is another bound like Send, Sync, or lifetime
+                                bounds.push(bound.to_token_stream());
+                            }
+                        }
+                        TypeParamBound::Lifetime(_) => {
+                            bounds.push(bound.to_token_stream());
+                        }
+                        _ => {
+                            // Handle any other bounds (e.g. Verbatim)
+                            bounds.push(bound.to_token_stream());
+                        }
+                    }
+                }
+
+                if let Some(item) = item_type {
+                    Ok((item, bounds))
+                } else {
+                    Err(Error::new_spanned(
+                        return_type,
+                        "Expected Iterator<Item = ...> in return type",
+                    ))
+                }
+            } else {
+                Err(Error::new_spanned(
+                    return_type,
+                    "Expected impl Iterator<...> return type",
+                ))
+            }
+        }
+        _ => Err(Error::new_spanned(
+            return_type,
+            "Expected -> impl Iterator<...> return type",
+        )),
+    }
+}
+
+fn is_iterator_trait(path: &Path) -> bool {
+    path.segments
+        .last()
+        .map(|seg| seg.ident == "Iterator")
+        .unwrap_or(false)
+}
+
+fn generate_boxed_return_type_with_lifetimes(
+    item_type: &TokenStream2,
+    bounds: &[TokenStream2],
+) -> TokenStream2 {
+    if bounds.is_empty() {
+        quote! { -> Box<dyn Iterator<Item = #item_type>> }
+    } else {
+        quote! { -> Box<dyn Iterator<Item = #item_type> + #(#bounds)+*> }
+    }
+}
diff --git a/raphtory-api-macros/tests/integration_test.rs b/raphtory-api-macros/tests/integration_test.rs
new file mode 100644
index 0000000000..3aaa79cb7c
--- /dev/null
+++ b/raphtory-api-macros/tests/integration_test.rs
@@ -0,0 +1,74 @@
+use raphtory_api_macros::box_on_debug_lifetime;
+
+struct LayerIds;
+struct Direction;
+struct EdgeRef;
+
+struct TestStruct;
+
+impl TestStruct {
+    #[box_on_debug_lifetime]
+    fn edge_iter<'a, 'b: 'a>(
+        &'a self,
+        _layer_ids: &'b LayerIds,
+    ) -> impl Iterator<Item = EdgeRef> + Send + Sync + 'a {
+        // Simplified version of your complex matching logic
+        std::iter::empty()
+    }
+}
+
+trait TestTrait<'a> {
+    type EntryRef;
+
+    fn edges_iter<'b>(
+        self,
+        layers_ids: &'b LayerIds,
+        dir: Direction,
+    ) -> impl Iterator<Item = EdgeRef> + Send + Sync + 'a
+    where
+        Self: Sized;
+}
+
+impl<'a> TestTrait<'a> for &'a TestStruct {
+    type EntryRef = EdgeRef;
+
+    #[box_on_debug_lifetime]
+    fn edges_iter<'b>(
+        self,
+        _layers_ids: &'b LayerIds,
+        _dir: Direction,
+    ) -> impl Iterator<Item = EdgeRef> + Send + Sync + 'a
+    where
+        Self: Sized,
+    {
+        std::iter::empty()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn can_send_and_sync<T: Send + Sync>(_t: &T) {}
+
+    #[test]
+    fn test_edge_iter() {
+        let test_struct = TestStruct;
+        let layer_ids = LayerIds;
+        let iter = test_struct.edge_iter(&layer_ids);
+        can_send_and_sync(&iter);
+        let collected: Vec<EdgeRef> = iter.collect();
+        assert_eq!(collected.len(), 0);
+    }
+
+    #[test]
+    fn test_edges_iter() {
+        let test_struct = TestStruct;
+        let layer_ids = LayerIds;
+        let direction = Direction;
+        let iter = (&test_struct).edges_iter(&layer_ids, direction);
+        can_send_and_sync(&iter);
+        let collected: Vec<EdgeRef> = iter.collect();
+        assert_eq!(collected.len(), 0);
+    }
+}
diff --git a/raphtory-api-macros/tests/macro_expansion_test.rs b/raphtory-api-macros/tests/macro_expansion_test.rs
new file mode 100644
index 0000000000..e981dc0f71
--- /dev/null
+++ b/raphtory-api-macros/tests/macro_expansion_test.rs
@@ -0,0 +1,26 @@
+use raphtory_api_macros::box_on_debug_lifetime;
+
+struct TestItem;
+
+#[box_on_debug_lifetime]
+fn test_function<'a>() -> impl Iterator<Item = TestItem> + Send + Sync + 'a {
+    std::iter::empty()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_debug_vs_release_types() {
+        let iter = test_function();
+        let _collected: Vec<TestItem> = iter.collect();
+    }
+
+    #[test]
+    #[cfg(debug_assertions)]
+    fn test_debug_build_returns_box() {
+        let iter = test_function();
+        let _boxed: Box<dyn Iterator<Item = TestItem> + Send + Sync> = iter;
+    }
+}
diff --git a/raphtory-api/Cargo.toml b/raphtory-api/Cargo.toml
index 38ea527905..7155bb5430 100644
--- a/raphtory-api/Cargo.toml
+++ b/raphtory-api/Cargo.toml
@@ -18,11 +18,12 @@ edition.workspace = true
 [dependencies]
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true, optional = true }
-bigdecimal = { workspace = true }
+bigdecimal = { workspace = true, features = ["string-only"] }
 thiserror = { workspace = true }
 bytemuck = { workspace = true }
 chrono.workspace = true
 dashmap = { workspace = true }
+derive_more = { workspace = true, features = ["from"] }
 rustc-hash = { workspace = true }
 lock_api = { workspace = true }
 parking_lot = { workspace = true }
@@ -35,9 +36,11 @@ twox-hash.workspace = true
 tracing-subscriber = { workspace = true }
 tracing = { workspace = true }
 sorted_vector_map = { workspace = true }
-arrow-array = { workspace = true, optional = true }
-arrow-ipc = { workspace = true, optional = true }
-arrow-schema = { workspace = true, optional = true }
+arrow-array = { workspace = true }
+arrow-buffer = { workspace = true }
+arrow-ipc = { workspace = true }
+arrow-schema = { workspace = true }
+serde_arrow = { workspace = true }
 itertools = { workspace = true }
 iter-enum = { workspace = true }
 minijinja = { workspace = true, optional = true }
@@ -45,21 +48,16 @@ display-error-chain = { workspace = true, optional = true }
 
 [dev-dependencies]
 proptest.workspace = true
+serde_json.workspace = true
 
 [features]
-default = []
 # Enables generating the pyo3 python bindings
 python = [
-    "dep:pyo3", "dep:pyo3-arrow", "dep:display-error-chain", "dep:arrow-schema"
-]
-
-storage = [
-    "dep:arrow-schema",
+    "dep:pyo3", "dep:pyo3-arrow", "dep:display-error-chain"
 ]
 
 proto = []
 vectors = []
 template = ["dep:minijinja"]
-arrow = ["dep:arrow-array", "dep:arrow-ipc", "dep:arrow-schema"]
 search = []
 io = ["dep:serde_json"]
diff --git a/raphtory-api/src/compute.rs b/raphtory-api/src/compute.rs
index 406ff281fd..2aab8b9842 100644
--- a/raphtory-api/src/compute.rs
+++ b/raphtory-api/src/compute.rs
@@ -1,5 +1,13 @@
 use rayon::prelude::*;
 /// Compute cumulative sum in parallel over `num_chunks` chunks
+pub fn cum_sum(values: &mut [usize]) {
+    let mut sum = 0;
+    for v in values {
+        sum += *v;
+        *v = sum;
+    }
+}
+
 pub fn par_cum_sum(values: &mut [usize]) {
     let num_chunks = rayon::current_num_threads();
     let chunk_size = values.len().div_ceil(num_chunks);
@@ -28,12 +36,12 @@ pub fn par_cum_sum(values: &mut [usize]) {
 
 #[cfg(test)]
 mod test {
-    use super::par_cum_sum;
+    use super::cum_sum;
 
     #[test]
     fn test_cum_sum() {
         let mut values: Vec<_> = (0..100).collect();
-        par_cum_sum(&mut values);
+        cum_sum(&mut values);
         let mut cum_sum = 0;
         for (index, v) in values.into_iter().enumerate() {
             cum_sum += index;
diff --git a/raphtory-api/src/core/entities/edges/edge_ref.rs b/raphtory-api/src/core/entities/edges/edge_ref.rs
index ceafb31a40..fa64271bfa 100644
--- a/raphtory-api/src/core/entities/edges/edge_ref.rs
+++ b/raphtory-api/src/core/entities/edges/edge_ref.rs
@@ -1,5 +1,5 @@
 use crate::core::{
-    entities::{EID, VID},
+    entities::{LayerId, EID, VID},
     storage::timeindex::{AsTime, EventTime},
 };
 use std::cmp::Ordering;
@@ -11,7 +11,7 @@ pub struct EdgeRef {
     dst_pid: VID,
     e_type: Dir,
     time: Option<EventTime>,
-    layer_id: Option<usize>,
+    layer_id: Option<LayerId>,
 }
 
 // This is used for merging iterators of EdgeRefs and only makes sense if the local node for both
@@ -66,7 +66,7 @@ impl EdgeRef {
     }
 
     #[inline(always)]
-    pub fn layer(&self) -> Option<usize> {
+    pub fn layer(&self) -> Option<LayerId> {
         self.layer_id
     }
 
@@ -124,7 +124,7 @@ impl EdgeRef {
     }
 
     #[inline]
-    pub fn at_layer(&self, layer: usize) -> Self {
+    pub fn at_layer(&self, layer: LayerId) -> Self {
         let mut e_ref = *self;
         e_ref.layer_id = Some(layer);
         e_ref
diff --git a/raphtory-api/src/core/entities/layers.rs b/raphtory-api/src/core/entities/layers.rs
index 1e5cc31650..74ee307452 100644
--- a/raphtory-api/src/core/entities/layers.rs
+++ b/raphtory-api/src/core/entities/layers.rs
@@ -1,10 +1,39 @@
 use crate::core::storage::arc_str::ArcStr;
+use bytemuck::{Pod, Zeroable};
 use iter_enum::{
     DoubleEndedIterator, ExactSizeIterator, FusedIterator, IndexedParallelIterator, Iterator,
     ParallelExtend, ParallelIterator,
 };
 use rayon::prelude::*;
-use std::{iter::Copied, sync::Arc};
+use serde::{Deserialize, Serialize};
+use std::{
+    fmt::{Display, Formatter, Result as FmtResult},
+    iter::Copied,
+    sync::Arc,
+};
+
+#[derive(
+    Debug, Copy, Clone, PartialEq, Eq, Ord, PartialOrd, Hash, Serialize, Deserialize, Pod, Zeroable,
+)]
+#[repr(transparent)]
+pub struct LayerId(pub usize);
+impl PartialEq<usize> for LayerId {
+    fn eq(&self, other: &usize) -> bool {
+        self.0 == *other
+    }
+}
+
+impl PartialEq<LayerId> for usize {
+    fn eq(&self, other: &LayerId) -> bool {
+        *self == other.0
+    }
+}
+
+impl Display for LayerId {
+    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
+        Display::fmt(&self.0, f)
+    }
+}
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Layer {
@@ -25,6 +54,17 @@ impl Layer {
             Layer::Multiple(layers) => layers.iter().any(|l| l == name),
         }
     }
+
+    fn from_iter<I: IntoIterator<Item: SingleLayer, IntoIter: ExactSizeIterator>>(
+        names: I,
+    ) -> Self {
+        let mut names = names.into_iter();
+        match names.len() {
+            0 => Layer::None,
+            1 => Layer::One(names.next().unwrap().name()),
+            _ => Layer::Multiple(names.map(|s| s.name()).collect::<Vec<_>>().into()),
+        }
+    }
 }
 
 pub trait SingleLayer {
@@ -77,33 +117,31 @@ impl<T: SingleLayer> SingleLayer for Option<T> {
 
 impl<T: SingleLayer> From<Vec<T>> for Layer {
     fn from(names: Vec<T>) -> Self {
-        match names.len() {
-            0 => Layer::None,
-            1 => Layer::One(names.into_iter().next().unwrap().name()),
-            _ => Layer::Multiple(
-                names
-                    .into_iter()
-                    .map(|s| s.name())
-                    .collect::<Vec<_>>()
-                    .into(),
-            ),
-        }
+        Self::from_iter(names)
     }
 }
 
 impl<T: SingleLayer, const N: usize> From<[T; N]> for Layer {
     fn from(names: [T; N]) -> Self {
-        match N {
-            0 => Layer::None,
-            1 => Layer::One(names.into_iter().next().unwrap().name()),
-            _ => Layer::Multiple(
-                names
-                    .into_iter()
-                    .map(|s| s.name())
-                    .collect::<Vec<_>>()
-                    .into(),
-            ),
-        }
+        Self::from_iter(names)
+    }
+}
+
+impl<'a, T: 'a> From<&'a [T]> for Layer
+where
+    &'a T: SingleLayer,
+{
+    fn from(names: &'a [T]) -> Self {
+        Self::from_iter(names)
+    }
+}
+
+impl<'a, T: 'a> From<&'a Vec<T>> for Layer
+where
+    &'a T: SingleLayer,
+{
+    fn from(names: &'a Vec<T>) -> Self {
+        Self::from_iter(names)
     }
 }
 
@@ -111,7 +149,7 @@ impl<T: SingleLayer, const N: usize> From<[T; N]> for Layer {
 pub enum LayerIds {
     None,
     All,
-    One(usize),
+    One(LayerId),
     Multiple(Multiple),
 }
 
@@ -132,11 +170,11 @@ pub enum LayerVariants<None, All, One, Multiple> {
 }
 
 #[derive(Clone, Debug, Default)]
-pub struct Multiple(pub Arc<[usize]>);
+pub struct Multiple(pub Arc<[LayerId]>);
 
 impl<'a> IntoIterator for &'a Multiple {
-    type Item = usize;
-    type IntoIter = Copied<core::slice::Iter<'a, usize>>;
+    type Item = LayerId;
+    type IntoIter = Copied<core::slice::Iter<'a, Self::Item>>;
 
     fn into_iter(self) -> Self::IntoIter {
         self.0.iter().copied()
@@ -145,33 +183,33 @@ impl<'a> IntoIterator for &'a Multiple {
 
 impl Multiple {
     #[inline]
-    pub fn contains(&self, id: usize) -> bool {
+    pub fn contains(&self, id: LayerId) -> bool {
         self.0.binary_search(&id).is_ok()
     }
 
     #[inline]
-    pub fn into_iter(&self) -> impl Iterator<Item = usize> {
+    pub fn into_iter(self) -> impl Iterator<Item = LayerId> {
         let ids = self.0.clone();
         (0..ids.len()).map(move |i| ids[i])
     }
 
     #[inline]
-    pub fn iter(&self) -> impl Iterator<Item = usize> + '_ {
+    pub fn iter(&self) -> impl Iterator<Item = LayerId> + '_ {
         self.0.iter().copied()
     }
 
     #[inline]
-    pub fn get_id_by_index(&self, index: usize) -> Option<usize> {
+    pub fn get_id_by_index(&self, index: usize) -> Option<LayerId> {
         self.0.get(index).copied()
     }
 
     #[inline]
-    pub fn get_index_by_id(&self, id: usize) -> Option<usize> {
+    pub fn get_index_by_id(&self, id: LayerId) -> Option<usize> {
         self.0.binary_search(&id).ok()
     }
 
     #[inline]
-    pub fn par_iter(&self) -> impl rayon::iter::ParallelIterator<Item = usize> {
+    pub fn par_iter(&self) -> impl rayon::iter::ParallelIterator<Item = LayerId> {
         let bit_vec = self.0.clone();
         (0..bit_vec.len()).into_par_iter().map(move |i| bit_vec[i])
     }
@@ -189,6 +227,15 @@ impl Multiple {
 
 impl FromIterator<usize> for Multiple {
     fn from_iter<I: IntoIterator<Item = usize>>(iter: I) -> Self {
+        let mut inner: Vec<_> = iter.into_iter().map(LayerId).collect();
+        inner.sort();
+        inner.dedup();
+        Multiple(inner.into())
+    }
+}
+
+impl FromIterator<LayerId> for Multiple {
+    fn from_iter<I: IntoIterator<Item = LayerId>>(iter: I) -> Self {
         let mut inner: Vec<_> = iter.into_iter().collect();
         inner.sort();
         inner.dedup();
@@ -196,8 +243,17 @@ impl FromIterator<usize> for Multiple {
     }
 }
 
+impl From<Vec<LayerId>> for Multiple {
+    fn from(mut v: Vec<LayerId>) -> Self {
+        v.sort();
+        v.dedup();
+        Multiple(v.into())
+    }
+}
+
 impl From<Vec<usize>> for Multiple {
-    fn from(mut v: Vec<usize>) -> Self {
+    fn from(v: Vec<usize>) -> Self {
+        let mut v: Vec<_> = v.into_iter().map(LayerId).collect();
         v.sort();
         v.dedup();
         Multiple(v.into())
diff --git a/raphtory-api/src/core/entities/mod.rs b/raphtory-api/src/core/entities/mod.rs
index cec2a58fbf..3225e71f36 100644
--- a/raphtory-api/src/core/entities/mod.rs
+++ b/raphtory-api/src/core/entities/mod.rs
@@ -1,7 +1,6 @@
 use super::input::input_node::parse_u64_strict;
 use crate::iter::IntoDynBoxed;
 use bytemuck::{Pod, Zeroable};
-use edges::edge_ref::EdgeRef;
 use num_traits::ToPrimitive;
 use serde::{Deserialize, Serialize};
 use std::{
@@ -14,6 +13,7 @@ pub mod edges;
 pub mod layers;
 pub mod properties;
 
+use crate::core::entities::properties::prop::PropType;
 pub use layers::*;
 
 // The only reason this is public is because the physical IDs of the nodes don’t move.
@@ -37,6 +37,11 @@ impl VID {
     pub fn as_u64(&self) -> u64 {
         self.0 as u64
     }
+
+    /// check if the VID points to a node
+    pub fn is_initialised(&self) -> bool {
+        self.0 != usize::MAX
+    }
 }
 
 impl From<usize> for VID {
@@ -64,15 +69,19 @@ impl Default for EID {
 }
 
 impl EID {
+    pub fn index(&self) -> usize {
+        self.0
+    }
+
     pub fn as_u64(self) -> u64 {
         self.0 as u64
     }
 
-    pub fn with_layer(self, layer: usize) -> ELID {
+    pub fn with_layer(self, layer: LayerId) -> ELID {
         ELID::new(self, layer)
     }
 
-    pub fn with_layer_deletion(self, layer: usize) -> ELID {
+    pub fn with_layer_deletion(self, layer: LayerId) -> ELID {
         ELID::new_deletion(self, layer)
     }
 }
@@ -95,6 +104,12 @@ impl EID {
     }
 }
 
+impl From<ELID> for EID {
+    fn from(elid: ELID) -> Self {
+        elid.edge
+    }
+}
+
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default, Serialize, Deserialize)]
 pub struct ELID {
     pub edge: EID,
@@ -115,22 +130,22 @@ const LAYER_FLAG: usize = 1usize.reverse_bits();
 pub const MAX_LAYER: usize = usize::MAX & !LAYER_FLAG;
 
 impl ELID {
-    pub fn new(edge: EID, layer: usize) -> Self {
+    pub fn new(edge: EID, layer: LayerId) -> Self {
         ELID {
             edge,
-            layer_and_deletion: layer,
+            layer_and_deletion: layer.0,
         }
     }
 
-    pub fn new_deletion(edge: EID, layer: usize) -> Self {
+    pub fn new_deletion(edge: EID, layer: LayerId) -> Self {
         ELID {
             edge,
-            layer_and_deletion: layer | LAYER_FLAG,
+            layer_and_deletion: layer.0 | LAYER_FLAG,
         }
     }
 
-    pub fn layer(&self) -> usize {
-        self.layer_and_deletion & !LAYER_FLAG
+    pub fn layer(&self) -> LayerId {
+        LayerId(self.layer_and_deletion & !LAYER_FLAG)
     }
 
     pub fn is_deletion(&self) -> bool {
@@ -226,7 +241,7 @@ impl GID {
         }
     }
 
-    pub fn to_str(&'_ self) -> Cow<'_, str> {
+    pub fn to_str(&self) -> Cow<'_, str> {
         match self {
             GID::U64(v) => Cow::Owned(v.to_string()),
             GID::Str(v) => Cow::Borrowed(v),
@@ -294,6 +309,40 @@ pub enum GidRef<'a> {
     Str(&'a str),
 }
 
+#[derive(Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, Serialize, Deserialize)]
+pub enum GidCow<'a> {
+    U64(u64),
+    Str(Cow<'a, str>),
+}
+
+impl<'a> From<GidRef<'a>> for GidCow<'a> {
+    fn from(value: GidRef<'a>) -> Self {
+        match value {
+            GidRef::U64(v) => Self::U64(v),
+            GidRef::Str(v) => Self::Str(Cow::Borrowed(v)),
+        }
+    }
+}
+
+impl<'a> GidCow<'a> {
+    pub fn as_ref<'b>(&'b self) -> GidRef<'b>
+    where
+        'a: 'b,
+    {
+        match self {
+            GidCow::U64(v) => GidRef::U64(*v),
+            GidCow::Str(v) => GidRef::Str(v),
+        }
+    }
+
+    pub fn into_owned(self) -> GID {
+        match self {
+            GidCow::U64(v) => GID::U64(v),
+            GidCow::Str(v) => GID::Str(v.into_owned()),
+        }
+    }
+}
+
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 pub enum GidType {
     U64,
@@ -313,11 +362,21 @@ impl Display for GidType {
     }
 }
 
+impl GidType {
+    pub fn from_prop_type(prop_type: &PropType) -> Option<Self> {
+        match prop_type {
+            PropType::Str => Some(GidType::Str),
+            PropType::U64 | PropType::U32 | PropType::I64 | PropType::I32 => Some(GidType::U64),
+            _ => None,
+        }
+    }
+}
+
 impl Display for GidRef<'_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
-            GidRef::U64(v) => write!(f, "{}", v),
-            GidRef::Str(v) => write!(f, "{}", v),
+            GidRef::U64(v) => write!(f, "{v}"),
+            GidRef::Str(v) => write!(f, "{v}"),
         }
     }
 }
@@ -337,6 +396,12 @@ impl<'a> From<&'a str> for GidRef<'a> {
     }
 }
 
+impl From<u64> for GidRef<'_> {
+    fn from(value: u64) -> Self {
+        GidRef::U64(value)
+    }
+}
+
 impl<'a> GidRef<'a> {
     pub fn dtype(self) -> GidType {
         match self {
@@ -389,13 +454,13 @@ impl<'a> GidRef<'a> {
 
 #[cfg(test)]
 mod test {
-    use crate::core::entities::Multiple;
+    use crate::core::entities::{LayerId, Multiple};
 
     #[test]
     fn empty_bit_multiple() {
         let bm = super::Multiple::default();
         let actual = bm.into_iter().collect::<Vec<_>>();
-        let expected: Vec<usize> = vec![];
+        let expected: Vec<LayerId> = vec![];
         assert_eq!(actual, expected);
     }
 
@@ -416,21 +481,6 @@ mod test {
 }
 
 impl LayerIds {
-    pub fn find(&self, layer_id: usize) -> Option<usize> {
-        match self {
-            LayerIds::All => Some(layer_id),
-            LayerIds::One(id) => {
-                if *id == layer_id {
-                    Some(layer_id)
-                } else {
-                    None
-                }
-            }
-            LayerIds::Multiple(ids) => ids.contains(layer_id).then_some(layer_id),
-            LayerIds::None => None,
-        }
-    }
-
     pub fn intersect(&self, other: &LayerIds) -> LayerIds {
         match (self, other) {
             (LayerIds::None, _) => LayerIds::None,
@@ -445,7 +495,7 @@ impl LayerIds {
                 }
             }
             (LayerIds::Multiple(ids), other) => {
-                let ids: Vec<usize> = ids.iter().filter(|id| other.contains(id)).collect();
+                let ids: Vec<_> = ids.iter().filter(|id| other.contains(id)).collect();
                 match ids.len() {
                     0 => LayerIds::None,
                     1 => LayerIds::One(ids[0]),
@@ -455,20 +505,15 @@ impl LayerIds {
         }
     }
 
-    pub fn constrain_from_edge(&self, e: EdgeRef) -> Cow<'_, LayerIds> {
-        match e.layer() {
-            None => Cow::Borrowed(self),
-            Some(l) => self
-                .find(l)
-                .map(|id| Cow::Owned(LayerIds::One(id)))
-                .unwrap_or(Cow::Owned(LayerIds::None)),
+    pub fn contains(&self, layer_id: &LayerId) -> bool {
+        match self {
+            LayerIds::All => true,
+            LayerIds::One(id) => id == layer_id,
+            LayerIds::Multiple(ids) => ids.contains(*layer_id),
+            LayerIds::None => false,
         }
     }
 
-    pub fn contains(&self, layer_id: &usize) -> bool {
-        self.find(*layer_id).is_some()
-    }
-
     pub fn is_none(&self) -> bool {
         matches!(self, LayerIds::None)
     }
@@ -477,18 +522,41 @@ impl LayerIds {
         matches!(self, LayerIds::One(_))
     }
 
-    pub fn iter(&self, num_layers: usize) -> impl Iterator<Item = usize> {
+    pub fn is_all(&self) -> bool {
+        matches!(self, LayerIds::All)
+    }
+
+    pub fn iter(&self, num_layers: usize) -> impl Iterator<Item = LayerId> + use<'_> {
         match self {
             LayerIds::None => iter::empty().into_dyn_boxed(),
-            LayerIds::All => (0..num_layers).into_dyn_boxed(),
+            LayerIds::All => (0..num_layers).map(LayerId).into_dyn_boxed(),
             LayerIds::One(id) => iter::once(*id).into_dyn_boxed(),
             LayerIds::Multiple(ids) => ids.into_iter().into_dyn_boxed(),
         }
     }
+
+    pub fn into_iter(self, num_layers: usize) -> impl Iterator<Item = LayerId> {
+        match self {
+            LayerIds::None => iter::empty().into_dyn_boxed(),
+            LayerIds::All => (0..num_layers).map(LayerId).into_dyn_boxed(),
+            LayerIds::One(id) => iter::once(id).into_dyn_boxed(),
+            LayerIds::Multiple(ids) => ids.into_iter().into_dyn_boxed(),
+        }
+    }
 }
 
 impl From<Vec<usize>> for LayerIds {
     fn from(v: Vec<usize>) -> Self {
+        match v.len() {
+            0 => LayerIds::All,
+            1 => LayerIds::One(LayerId(v[0])),
+            _ => LayerIds::Multiple(v.into()),
+        }
+    }
+}
+
+impl From<Vec<LayerId>> for LayerIds {
+    fn from(v: Vec<LayerId>) -> Self {
         match v.len() {
             0 => LayerIds::All,
             1 => LayerIds::One(v[0]),
@@ -499,6 +567,16 @@ impl From<Vec<usize>> for LayerIds {
 
 impl<const N: usize> From<[usize; N]> for LayerIds {
     fn from(v: [usize; N]) -> Self {
+        match v.len() {
+            0 => LayerIds::All,
+            1 => LayerIds::One(LayerId(v[0])),
+            _ => LayerIds::Multiple(v.into_iter().collect()),
+        }
+    }
+}
+
+impl<const N: usize> From<[LayerId; N]> for LayerIds {
+    fn from(v: [LayerId; N]) -> Self {
         match v.len() {
             0 => LayerIds::All,
             1 => LayerIds::One(v[0]),
@@ -509,24 +587,30 @@ impl<const N: usize> From<[usize; N]> for LayerIds {
 
 impl From<usize> for LayerIds {
     fn from(id: usize) -> Self {
+        LayerIds::One(LayerId(id))
+    }
+}
+
+impl From<LayerId> for LayerIds {
+    fn from(id: LayerId) -> Self {
         LayerIds::One(id)
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::core::entities::{EID, MAX_LAYER};
+    use crate::core::entities::{LayerId, EID, MAX_LAYER};
     use proptest::{prop_assert, prop_assert_eq, proptest};
 
     #[test]
     fn test_elid_layer() {
         proptest!(|(eid in 0..=usize::MAX, layer in 0..=MAX_LAYER)| {
-            let elid = EID(eid).with_layer(layer);
-            prop_assert_eq!(elid.layer(), layer);
+            let elid = EID(eid).with_layer(LayerId(layer));
+            prop_assert_eq!(elid.layer(), LayerId(layer));
             prop_assert!(!elid.is_deletion());
 
             let elid_deleted = elid.into_deletion();
-            prop_assert_eq!(elid_deleted.layer(), layer);
+            prop_assert_eq!(elid_deleted.layer(), LayerId(layer));
             prop_assert_eq!(elid_deleted.edge, EID(eid));
             prop_assert!(elid_deleted.is_deletion())
         })
@@ -535,8 +619,8 @@ mod tests {
     #[test]
     fn test_elid_deletion() {
         proptest!(|(eid in 0..=usize::MAX, layer in 0..=MAX_LAYER)| {
-            let elid = EID(eid).with_layer_deletion(layer);
-            prop_assert_eq!(elid.layer(), layer);
+            let elid = EID(eid).with_layer_deletion(LayerId(layer));
+            prop_assert_eq!(elid.layer(), LayerId(layer));
             prop_assert!(elid.is_deletion());
             prop_assert_eq!(elid, elid.into_deletion());
             prop_assert_eq!(elid.edge.0, eid);
diff --git a/raphtory-api/src/core/entities/properties/meta.rs b/raphtory-api/src/core/entities/properties/meta.rs
index b227ca1c91..6113f87596 100644
--- a/raphtory-api/src/core/entities/properties/meta.rs
+++ b/raphtory-api/src/core/entities/properties/meta.rs
@@ -1,18 +1,39 @@
-use std::{ops::Deref, sync::Arc};
-
-use parking_lot::RwLock;
-use serde::{Deserialize, Serialize};
-
 use crate::core::{
-    entities::properties::prop::{unify_types, PropError, PropType},
+    entities::{
+        properties::prop::{check_for_unification, unify_types, PropError, PropType},
+        LayerId,
+    },
     storage::{
         arc_str::ArcStr,
-        dict_mapper::{DictMapper, MaybeNew},
-        locked_vec::ArcReadLockedVec,
+        dict_mapper::{DictMapper, LockedDictMapper, MaybeNew, PublicKeys, WriteLockedDictMapper},
     },
 };
+use itertools::Either;
+use parking_lot::{RwLock, RwLockReadGuard, RwLockWriteGuard};
+use rustc_hash::FxHashMap;
+use serde::{Deserialize, Serialize};
+use std::{
+    ops::{Deref, DerefMut},
+    sync::{
+        atomic::{self, AtomicUsize},
+        Arc,
+    },
+};
+
+// Internal const props for node id and type
+pub const NODE_ID_PROP_KEY: &str = "_raphtory_node_id";
+pub const NODE_ID_IDX: usize = 0;
 
-#[derive(Serialize, Deserialize, Debug)]
+pub const NODE_TYPE_PROP_KEY: &str = "_raphtory_node_type";
+pub const NODE_TYPE_IDX: usize = 1;
+
+pub const STATIC_GRAPH_LAYER: &str = "_static_graph";
+pub const STATIC_GRAPH_LAYER_ID: LayerId = LayerId(0);
+
+/// The type ID for nodes that don't have a specified type.
+pub const DEFAULT_NODE_TYPE_ID: usize = 0;
+
+#[derive(Serialize, Deserialize, Debug, Default)]
 pub struct Meta {
     temporal_prop_mapper: PropMapper,
     metadata_mapper: PropMapper,
@@ -20,19 +41,25 @@ pub struct Meta {
     node_type_mapper: DictMapper,
 }
 
-impl Default for Meta {
-    fn default() -> Self {
-        Self::new()
+impl Meta {
+    pub fn all_layer_iter(&self) -> impl Iterator<Item = (LayerId, ArcStr)> + use<'_> {
+        self.layer_mapper
+            .all_ids()
+            .map(LayerId)
+            .zip(self.layer_mapper.all_keys())
     }
-}
 
-impl Meta {
     pub fn set_metadata_mapper(&mut self, meta: PropMapper) {
         self.metadata_mapper = meta;
     }
-    pub fn set_temporal_prop_meta(&mut self, meta: PropMapper) {
+
+    pub fn set_temporal_prop_mapper(&mut self, meta: PropMapper) {
         self.temporal_prop_mapper = meta;
     }
+
+    pub fn set_layer_mapper(&mut self, meta: DictMapper) {
+        self.layer_mapper = meta;
+    }
     pub fn metadata_mapper(&self) -> &PropMapper {
         &self.metadata_mapper
     }
@@ -49,10 +76,37 @@ impl Meta {
         &self.node_type_mapper
     }
 
-    pub fn new() -> Self {
-        let meta_layer = DictMapper::default();
+    #[inline]
+    pub fn temporal_est_row_size(&self) -> usize {
+        self.temporal_prop_mapper.row_size()
+    }
+
+    #[inline]
+    pub fn const_est_row_size(&self) -> usize {
+        self.metadata_mapper.row_size()
+    }
+
+    pub fn new_for_nodes() -> Self {
+        let meta_layer = DictMapper::new_layer_mapper();
         let meta_node_type = DictMapper::default();
         meta_node_type.get_or_create_id("_default");
+
+        Self {
+            temporal_prop_mapper: PropMapper::default(),
+            metadata_mapper: PropMapper::new_with_private_fields(
+                [NODE_ID_PROP_KEY, NODE_TYPE_PROP_KEY],
+                [PropType::Empty, PropType::U64],
+            ),
+            layer_mapper: meta_layer,
+            node_type_mapper: meta_node_type, // type 0 is the default type for a node
+        }
+    }
+
+    pub fn new_for_edges() -> Self {
+        let meta_layer = DictMapper::new_layer_mapper();
+        let meta_node_type = DictMapper::default();
+        meta_node_type.get_or_create_id("_default");
+
         Self {
             temporal_prop_mapper: PropMapper::default(),
             metadata_mapper: PropMapper::default(),
@@ -61,6 +115,19 @@ impl Meta {
         }
     }
 
+    pub fn new_for_graph_props() -> Self {
+        let meta_layer = DictMapper::new_layer_mapper();
+        let meta_node_type = DictMapper::default();
+
+        // For now, only temporal and metadata mappers are used for graph metadata.
+        Self {
+            temporal_prop_mapper: PropMapper::default(),
+            metadata_mapper: PropMapper::default(),
+            layer_mapper: meta_layer,
+            node_type_mapper: meta_node_type,
+        }
+    }
+
     #[inline]
     pub fn resolve_prop_id(
         &self,
@@ -93,14 +160,15 @@ impl Meta {
     }
 
     #[inline]
-    pub fn get_or_create_layer_id(&self, name: Option<&str>) -> MaybeNew<usize> {
+    pub fn get_or_create_layer_id(&self, name: Option<&str>) -> MaybeNew<LayerId> {
         self.layer_mapper
             .get_or_create_id(name.unwrap_or("_default"))
+            .map(|l| LayerId(l))
     }
 
     #[inline]
     pub fn get_default_node_type_id(&self) -> usize {
-        0usize
+        DEFAULT_NODE_TYPE_ID
     }
 
     #[inline]
@@ -109,13 +177,13 @@ impl Meta {
     }
 
     #[inline]
-    pub fn get_layer_id(&self, name: &str) -> Option<usize> {
-        self.layer_mapper.get_id(name)
+    pub fn get_layer_id(&self, name: &str) -> Option<LayerId> {
+        self.layer_mapper.get_id(name).map(|l| LayerId(l))
     }
 
     #[inline]
-    pub fn get_default_layer_id(&self) -> Option<usize> {
-        self.layer_mapper.get_id("_default")
+    pub fn get_default_layer_id(&self) -> Option<LayerId> {
+        self.layer_mapper.get_id("_default").map(|id| LayerId(id))
     }
 
     #[inline]
@@ -123,25 +191,21 @@ impl Meta {
         self.node_type_mapper.get_id(node_type)
     }
 
-    pub fn get_layer_name_by_id(&self, id: usize) -> ArcStr {
-        self.layer_mapper.get_name(id)
+    pub fn get_layer_name_by_id(&self, id: LayerId) -> ArcStr {
+        self.layer_mapper.get_name(id.0)
     }
 
     pub fn get_node_type_name_by_id(&self, id: usize) -> Option<ArcStr> {
-        if id == 0 {
+        if id == DEFAULT_NODE_TYPE_ID {
             None
         } else {
             Some(self.node_type_mapper.get_name(id))
         }
     }
 
-    pub fn get_all_layers(&self) -> Vec<usize> {
-        self.layer_mapper.get_values()
-    }
-
     pub fn get_all_node_types(&self) -> Vec<ArcStr> {
         self.node_type_mapper
-            .get_keys()
+            .keys()
             .iter()
             .filter_map(|key| {
                 if key != "_default" {
@@ -153,11 +217,11 @@ impl Meta {
             .collect()
     }
 
-    pub fn get_all_property_names(&self, is_static: bool) -> ArcReadLockedVec<ArcStr> {
+    pub fn get_all_property_names(&self, is_static: bool) -> PublicKeys<ArcStr> {
         if is_static {
-            self.metadata_mapper.get_keys()
+            self.metadata_mapper.keys()
         } else {
-            self.temporal_prop_mapper.get_keys()
+            self.temporal_prop_mapper.keys()
         }
     }
 
@@ -173,6 +237,7 @@ impl Meta {
 #[derive(Default, Debug, Serialize, Deserialize)]
 pub struct PropMapper {
     id_mapper: DictMapper,
+    row_size: AtomicUsize,
     dtypes: Arc<RwLock<Vec<PropType>>>,
 }
 
@@ -186,14 +251,38 @@ impl Deref for PropMapper {
 }
 
 impl PropMapper {
+    pub fn new_with_private_fields(
+        fields: impl IntoIterator<Item = impl Into<ArcStr>>,
+        dtypes: impl IntoIterator<Item = PropType>,
+    ) -> Self {
+        let dtypes = Vec::from_iter(dtypes);
+        let row_size = dtypes.iter().map(|dtype| dtype.est_size()).sum();
+
+        PropMapper {
+            id_mapper: DictMapper::new_with_private_fields(fields),
+            row_size: AtomicUsize::new(row_size),
+            dtypes: Arc::new(RwLock::new(dtypes)),
+        }
+    }
+
+    pub fn d_types(&self) -> impl Deref<Target = Vec<PropType>> + '_ {
+        self.dtypes.read_recursive()
+    }
+
     pub fn deep_clone(&self) -> Self {
         let dtypes = self.dtypes.read_recursive().clone();
         Self {
             id_mapper: self.id_mapper.deep_clone(),
+            row_size: AtomicUsize::new(self.row_size.load(std::sync::atomic::Ordering::Relaxed)),
             dtypes: Arc::new(RwLock::new(dtypes)),
         }
     }
 
+    #[inline]
+    pub fn row_size(&self) -> usize {
+        self.row_size.load(atomic::Ordering::Relaxed)
+    }
+
     pub fn get_id_and_dtype(&self, prop: &str) -> Option<(usize, PropType)> {
         self.get_id(prop).map(|id| {
             let existing_dtype = self
@@ -244,6 +333,8 @@ impl PropMapper {
             None => {
                 // vector not resized yet, resize it and set the dtype and return id
                 dtype_write.resize(id + 1, PropType::Empty);
+                self.row_size
+                    .fetch_add(dtype.est_size(), atomic::Ordering::Relaxed);
                 dtype_write[id] = dtype;
                 Ok(wrapped_id)
             }
@@ -251,11 +342,17 @@ impl PropMapper {
     }
 
     pub fn set_id_and_dtype(&self, key: impl Into<ArcStr>, id: usize, dtype: PropType) {
-        let mut dtypes = self.dtypes.write();
         self.set_id(key, id);
+        self.set_dtype(id, dtype);
+    }
+
+    pub fn set_dtype(&self, id: usize, dtype: PropType) {
+        let mut dtypes = self.dtypes.write();
         if dtypes.len() <= id {
             dtypes.resize(id + 1, PropType::Empty);
         }
+        self.row_size
+            .fetch_add(dtype.est_size(), atomic::Ordering::Relaxed);
         dtypes[id] = dtype;
     }
 
@@ -263,8 +360,159 @@ impl PropMapper {
         self.dtypes.read_recursive().get(prop_id).cloned()
     }
 
-    pub fn dtypes(&self) -> impl Deref<Target = Vec<PropType>> + '_ {
-        self.dtypes.read_recursive()
+    pub fn locked(&self) -> LockedPropMapper<'_> {
+        LockedPropMapper {
+            dict_mapper: self.id_mapper.read(),
+            d_types: self.dtypes.read_recursive(),
+        }
+    }
+
+    pub fn write_locked(&self) -> WriteLockedPropMapper<'_> {
+        WriteLockedPropMapper {
+            dict_mapper: self.id_mapper.write(),
+            d_types: self.dtypes.write(),
+        }
+    }
+}
+
+pub struct LockedPropMapper<'a> {
+    dict_mapper: LockedDictMapper<'a>,
+    d_types: RwLockReadGuard<'a, Vec<PropType>>,
+}
+
+pub struct WriteLockedPropMapper<'a> {
+    dict_mapper: WriteLockedDictMapper<'a>,
+    d_types: RwLockWriteGuard<'a, Vec<PropType>>,
+}
+
+impl<'a> WriteLockedPropMapper<'a> {
+    pub fn get_dtype(&'a self, prop_id: usize) -> Option<&'a PropType> {
+        self.d_types.get(prop_id)
+    }
+
+    /// Fast check for property type without unifying the types
+    /// Returns:
+    /// - `Some(Either::Left(id))` if the property type can be unified
+    /// - `Some(Either::Right(id))` if the property type is already set and no unification is needed
+    /// - `None` if the property type is not set
+    /// - `Err(PropError::PropertyTypeError)` if the property type cannot be unified
+    pub fn fast_proptype_check(
+        &mut self,
+        prop: &str,
+        dtype: PropType,
+    ) -> Result<Option<Either<usize, usize>>, PropError> {
+        fast_proptype_check(self.dict_mapper.map(), &self.d_types, prop, dtype)
+    }
+
+    pub fn set_id_and_dtype(&mut self, key: impl Into<ArcStr>, id: usize, dtype: PropType) {
+        self.dict_mapper.set_id(key, id);
+        self.set_dtype(id, dtype);
+    }
+
+    pub fn set_or_unify_id_and_dtype(
+        &mut self,
+        key: impl Into<ArcStr>,
+        id: usize,
+        dtype: PropType,
+    ) -> Result<(), PropError> {
+        self.dict_mapper.set_id(key, id);
+        self.set_or_unify_dtype(id, dtype)
+    }
+
+    pub fn set_dtype(&mut self, id: usize, dtype: PropType) {
+        let dtypes = self.d_types.deref_mut();
+        if dtypes.len() <= id {
+            dtypes.resize(id + 1, PropType::Empty);
+        }
+        dtypes[id] = dtype;
+    }
+
+    pub fn set_or_unify_dtype(&mut self, id: usize, dtype: PropType) -> Result<(), PropError> {
+        let dtypes = self.d_types.deref_mut();
+        match dtypes.get_mut(id) {
+            None => {
+                dtypes.resize(id + 1, PropType::Empty);
+                dtypes[id] = dtype;
+            }
+            Some(old_dtype) => {
+                let mut unified = false;
+                let unified_type = unify_types(&old_dtype, &dtype, &mut unified)?;
+                *old_dtype = unified_type;
+            }
+        }
+        Ok(())
+    }
+
+    pub fn new_id_and_dtype(&mut self, key: impl Into<ArcStr>, dtype: PropType) -> usize {
+        let id = self.dict_mapper.get_or_create_id(&key.into());
+        let dtypes = self.d_types.deref_mut();
+        if dtypes.len() <= id.inner() {
+            dtypes.resize(id.inner() + 1, PropType::Empty);
+        }
+        dtypes[id.inner()] = dtype;
+        id.inner()
+    }
+}
+
+impl<'a> LockedPropMapper<'a> {
+    pub fn get_id(&self, prop: &str) -> Option<usize> {
+        self.dict_mapper.get_id(prop)
+    }
+
+    pub fn get_dtype(&'a self, prop_id: usize) -> Option<&'a PropType> {
+        self.d_types.get(prop_id)
+    }
+
+    /// Fast check for property type without unifying the types
+    /// Returns:
+    /// - `Some(Either::Left(id))` if the property type can be unified
+    /// - `Some(Either::Right(id))` if the property type is already set and no unification is needed
+    /// - `None` if the property type is not set
+    /// - `Err(PropError::PropertyTypeError)` if the property type cannot be unified
+    pub fn fast_proptype_check(
+        &self,
+        prop: &str,
+        dtype: PropType,
+    ) -> Result<Option<Either<usize, usize>>, PropError> {
+        fast_proptype_check(self.dict_mapper.map(), &self.d_types, prop, dtype)
+    }
+
+    pub fn iter_ids_and_types(&self) -> impl Iterator<Item = (usize, &ArcStr, &PropType)> {
+        self.dict_mapper
+            .iter_ids()
+            .map(move |(id, name)| (id, name, &self.d_types[id]))
+    }
+}
+
+fn fast_proptype_check(
+    mapper: &FxHashMap<ArcStr, usize>,
+    d_types: &[PropType],
+    prop: &str,
+    dtype: PropType,
+) -> Result<Option<Either<usize, usize>>, PropError> {
+    match mapper.get(prop) {
+        Some(&id) => {
+            let existing_dtype = d_types
+                .get(id)
+                .expect("Existing id should always have a dtype");
+
+            let fast_check = check_for_unification(&dtype, existing_dtype);
+            if fast_check.is_none() {
+                // means nothing to do
+                return Ok(Some(Either::Right(id)));
+            }
+            let can_unify = fast_check.unwrap();
+            if can_unify {
+                Ok(Some(Either::Left(id)))
+            } else {
+                Err(PropError {
+                    name: prop.to_string(),
+                    expected: existing_dtype.clone(),
+                    actual: dtype,
+                })
+            }
+        }
+        None => Ok(None),
     }
 }
 
diff --git a/raphtory-api/src/core/entities/properties/prop/arrow.rs b/raphtory-api/src/core/entities/properties/prop/arrow.rs
index 22bc5c1b43..f38f723042 100644
--- a/raphtory-api/src/core/entities/properties/prop/arrow.rs
+++ b/raphtory-api/src/core/entities/properties/prop/arrow.rs
@@ -1,5 +1,368 @@
-use crate::core::{
-    entities::properties::{prop::Prop, prop_array::PropArray},
-    PropType,
+use std::borrow::Cow;
+
+use arrow_array::{
+    cast::AsArray, types::*, Array, ArrowPrimitiveType, OffsetSizeTrait, StructArray,
 };
-use std::sync::Arc;
+use arrow_schema::{DataType, TimeUnit};
+use chrono::DateTime;
+use itertools::Itertools;
+use serde::{ser::SerializeMap, Serialize};
+
+use crate::core::entities::properties::prop::{Prop, PropArray, PropRef};
+
+pub const EMPTY_MAP_FIELD_NAME: &str = "__empty__";
+
+#[derive(Debug, Clone, Copy)]
+pub struct ArrowRow<'a> {
+    array: &'a StructArray,
+    index: usize,
+}
+
+impl<'a> Serialize for ArrowRow<'a> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut state = serializer.serialize_map(Some(self.array.num_columns()))?;
+        for col in 0..self.array.num_columns() {
+            let field = &self.array.fields()[col];
+            let key = field.name();
+            let value = self.prop_ref(col);
+            state.serialize_entry(key, &value)?;
+        }
+        state.end()
+    }
+}
+
+impl<'a> ArrowRow<'a> {
+    pub fn primitive_value<T: ArrowPrimitiveType>(&self, col: usize) -> Option<T::Native> {
+        let primitive_array = self.array.column(col).as_primitive_opt::<T>()?;
+        (primitive_array.len() > self.index && !primitive_array.is_null(self.index))
+            .then(|| primitive_array.value(self.index))
+    }
+
+    fn primitive_dt<T: DirectConvert>(&self, col: usize) -> Option<(T::Native, &DataType)> {
+        let col = self.array.column(col).as_primitive_opt::<T>()?;
+        (col.len() > self.index && !col.is_null(self.index))
+            .then(|| (col.value(self.index), col.data_type()))
+    }
+
+    fn primitive_prop<T: DirectConvert>(&self, col: usize) -> Option<Prop> {
+        let (value, dt) = self.primitive_dt::<T>(col)?;
+        let prop = T::prop(value, dt);
+        Some(prop)
+    }
+
+    fn primitive_prop_ref<T: DirectConvert>(self, col: usize) -> Option<PropRef<'static>> {
+        let col = self.array.column(col).as_primitive_opt::<T>()?;
+        let (value, dt) = (col.len() > self.index && !col.is_null(self.index))
+            .then(|| (col.value(self.index), col.data_type()))?;
+        let prop_ref = T::prop_ref(value, dt);
+        Some(prop_ref)
+    }
+
+    fn struct_prop(&self, col: usize) -> Option<Prop> {
+        let col = self.array.column(col).as_struct_opt()?;
+        let row = ArrowRow::new(col, self.index);
+        if col.len() > self.index && !col.is_null(self.index) {
+            row.into_prop()
+        } else {
+            None
+        }
+    }
+
+    fn list_prop<O: OffsetSizeTrait>(&self, col: usize) -> Option<Prop> {
+        let col = self.array.column(col).as_list_opt::<O>()?;
+        let row = col.value(self.index);
+        if col.len() > self.index && !col.is_null(self.index) {
+            Some(row.into())
+        } else {
+            None
+        }
+    }
+
+    fn struct_prop_ref(&self, col: usize) -> Option<PropRef<'a>> {
+        let column = self.array.column(col).as_struct_opt()?;
+        if self.index < column.len() && column.is_valid(self.index) {
+            let row = ArrowRow::new(column, self.index);
+            Some(PropRef::from(row))
+        } else {
+            None
+        }
+    }
+
+    fn list_prop_ref(&self, col: usize) -> Option<PropRef<'a>> {
+        let column = self.array.column(col).as_list_opt::<i64>()?;
+        if self.index < column.len() && column.is_valid(self.index) {
+            let list_array = column.value(self.index);
+            Some(PropRef::List(Cow::Owned(PropArray::from(list_array))))
+        } else {
+            None
+        }
+    }
+
+    pub fn bool_value(&self, col: usize) -> Option<bool> {
+        let column = self.array.column(col);
+        match column.data_type() {
+            DataType::Boolean => {
+                let col = column.as_boolean();
+                (col.len() > self.index && !col.is_null(self.index)).then(|| col.value(self.index))
+            }
+            _ => None,
+        }
+    }
+
+    pub fn str_value(self, col: usize) -> Option<&'a str> {
+        let column = self.array.column(col);
+        let len = column.len();
+        let valid = len > self.index && !column.is_null(self.index);
+        match column.data_type() {
+            DataType::Utf8 => valid.then(|| column.as_string::<i32>().value(self.index)),
+            DataType::LargeUtf8 => valid.then(|| column.as_string::<i64>().value(self.index)),
+            DataType::Utf8View => valid.then(|| column.as_string_view().value(self.index)),
+            _ => None,
+        }
+    }
+
+    pub fn prop_value(self, col: usize) -> Option<Prop> {
+        let dtype = self.array.fields().get(col)?.data_type();
+        match dtype {
+            DataType::Null => None,
+            DataType::Boolean => self.bool_value(col).map(|b| b.into()),
+            DataType::Int32 => self.primitive_prop::<Int32Type>(col),
+            DataType::Int64 => self.primitive_prop::<Int64Type>(col),
+            DataType::UInt8 => self.primitive_prop::<UInt8Type>(col),
+            DataType::UInt16 => self.primitive_prop::<UInt16Type>(col),
+            DataType::UInt32 => self.primitive_prop::<UInt32Type>(col),
+            DataType::UInt64 => self.primitive_prop::<UInt64Type>(col),
+            DataType::Float32 => self.primitive_prop::<Float32Type>(col),
+            DataType::Float64 => self.primitive_prop::<Float64Type>(col),
+            DataType::Timestamp(unit, _) => match unit {
+                TimeUnit::Second => self.primitive_prop::<TimestampSecondType>(col),
+                TimeUnit::Millisecond => self.primitive_prop::<TimestampMillisecondType>(col),
+                TimeUnit::Microsecond => self.primitive_prop::<TimestampMicrosecondType>(col),
+                TimeUnit::Nanosecond => self.primitive_prop::<TimestampNanosecondType>(col),
+            },
+            DataType::Date32 => self.primitive_prop::<Date32Type>(col),
+            DataType::Date64 => self.primitive_prop::<Date64Type>(col),
+            DataType::Utf8 | DataType::LargeUtf8 | DataType::Utf8View => {
+                self.str_value(col).map(|v| v.into())
+            }
+            DataType::Decimal128(_, _) => self.primitive_prop::<Decimal128Type>(col),
+            DataType::Struct(_) => self.struct_prop(col),
+            DataType::List(_) => self.list_prop::<i32>(col),
+            DataType::LargeList(_) => self.list_prop::<i64>(col),
+            _ => None,
+        }
+    }
+
+    pub fn prop_ref(self, col: usize) -> Option<PropRef<'a>> {
+        let dtype = self.array.fields().get(col)?.data_type();
+        match dtype {
+            DataType::Null => None,
+            DataType::Boolean => self.bool_value(col).map(|b| b.into()),
+            DataType::Int32 => self.primitive_prop_ref::<Int32Type>(col),
+            DataType::Int64 => self.primitive_prop_ref::<Int64Type>(col),
+            DataType::UInt8 => self.primitive_prop_ref::<UInt8Type>(col),
+            DataType::UInt16 => self.primitive_prop_ref::<UInt16Type>(col),
+            DataType::UInt32 => self.primitive_prop_ref::<UInt32Type>(col),
+            DataType::UInt64 => self.primitive_prop_ref::<UInt64Type>(col),
+            DataType::Float32 => self.primitive_prop_ref::<Float32Type>(col),
+            DataType::Float64 => self.primitive_prop_ref::<Float64Type>(col),
+            DataType::Timestamp(unit, _) => match unit {
+                TimeUnit::Second => self.primitive_prop_ref::<TimestampSecondType>(col),
+                TimeUnit::Millisecond => self.primitive_prop_ref::<TimestampMillisecondType>(col),
+                TimeUnit::Microsecond => self.primitive_prop_ref::<TimestampMicrosecondType>(col),
+                TimeUnit::Nanosecond => self.primitive_prop_ref::<TimestampNanosecondType>(col),
+            },
+            DataType::Date32 => self.primitive_prop_ref::<Date32Type>(col),
+            DataType::Date64 => self.primitive_prop_ref::<Date64Type>(col),
+            DataType::Utf8 | DataType::LargeUtf8 | DataType::Utf8View => {
+                self.str_value(col).map(|v| v.into())
+            }
+            DataType::Decimal128(_, _) => self.primitive_prop_ref::<Decimal128Type>(col),
+            DataType::Struct(_) => self.struct_prop_ref(col),
+            DataType::LargeList(_) => self.list_prop_ref(col),
+            _ => None,
+        }
+    }
+
+    pub fn into_prop(self) -> Option<Prop> {
+        if self.index >= self.array.len() || self.array.is_null(self.index) {
+            None
+        } else {
+            let map = Prop::map(
+                self.array
+                    .fields()
+                    .iter()
+                    .enumerate()
+                    .filter_map(|(col, field)| {
+                        Some((field.name().as_ref(), self.prop_value(col)?))
+                    }),
+            );
+            Some(map)
+        }
+    }
+
+    pub fn is_valid(&self, col: usize) -> bool {
+        let col = self.array.column(col);
+        !col.data_type().is_null() && col.is_valid(self.index)
+    }
+
+    pub fn any_valid(&self) -> bool {
+        self.array
+            .columns()
+            .iter()
+            .any(|col| !col.data_type().is_null() && col.is_valid(self.index))
+    }
+
+    pub fn first_valid(&self) -> Option<usize> {
+        self.array
+            .columns()
+            .iter()
+            .find_position(|col| !col.data_type().is_null() && col.is_valid(self.index))
+            .map(|(pos, _)| pos)
+    }
+}
+
+impl<'a> ArrowRow<'a> {
+    pub fn new(array: &'a StructArray, index: usize) -> Self {
+        Self { array, index }
+    }
+
+    pub fn get<T: 'static>(&self, column: usize) -> Option<&T> {
+        self.array.column(column).as_any().downcast_ref()
+    }
+}
+
+pub trait DirectConvert: ArrowPrimitiveType {
+    fn prop_ref(native: Self::Native, dtype: &DataType) -> PropRef<'static>;
+    fn prop(native: Self::Native, dtype: &DataType) -> Prop {
+        Self::prop_ref(native, dtype).into()
+    }
+}
+
+impl DirectConvert for UInt8Type {
+    fn prop_ref(native: Self::Native, _dtype: &DataType) -> PropRef<'static> {
+        PropRef::from(native)
+    }
+}
+
+impl DirectConvert for UInt16Type {
+    fn prop_ref(native: Self::Native, _dtype: &DataType) -> PropRef<'static> {
+        PropRef::from(native)
+    }
+}
+
+impl DirectConvert for UInt32Type {
+    fn prop_ref(native: Self::Native, _dtype: &DataType) -> PropRef<'static> {
+        PropRef::from(native)
+    }
+}
+
+impl DirectConvert for UInt64Type {
+    fn prop_ref(native: Self::Native, _dtype: &DataType) -> PropRef<'static> {
+        PropRef::from(native)
+    }
+}
+
+impl DirectConvert for Int32Type {
+    fn prop_ref(native: Self::Native, _dtype: &DataType) -> PropRef<'static> {
+        PropRef::from(native)
+    }
+}
+
+impl DirectConvert for Int64Type {
+    fn prop_ref(native: Self::Native, _dtype: &DataType) -> PropRef<'static> {
+        PropRef::from(native)
+    }
+}
+
+impl DirectConvert for Float32Type {
+    fn prop_ref(native: Self::Native, _dtype: &DataType) -> PropRef<'static> {
+        PropRef::from(native)
+    }
+}
+
+impl DirectConvert for Float64Type {
+    fn prop_ref(native: Self::Native, _dtype: &DataType) -> PropRef<'static> {
+        PropRef::from(native)
+    }
+}
+
+impl DirectConvert for Date64Type {
+    fn prop_ref(native: Self::Native, _dtype: &DataType) -> PropRef<'static> {
+        PropRef::from(DateTime::from_timestamp_millis(native).unwrap())
+    }
+}
+
+impl DirectConvert for Date32Type {
+    fn prop_ref(native: Self::Native, _dtype: &DataType) -> PropRef<'static> {
+        PropRef::from(
+            Date32Type::to_naive_date(native)
+                .and_hms_opt(0, 0, 0)
+                .unwrap()
+                .and_utc(),
+        )
+    }
+}
+
+impl DirectConvert for TimestampNanosecondType {
+    fn prop_ref(native: Self::Native, dtype: &DataType) -> PropRef<'static> {
+        match dtype {
+            DataType::Timestamp(_, tz) => match tz {
+                None => PropRef::from(DateTime::from_timestamp_nanos(native).naive_utc()),
+                Some(_) => PropRef::from(DateTime::from_timestamp_nanos(native)),
+            },
+            _ => unreachable!(),
+        }
+    }
+}
+
+impl DirectConvert for TimestampMicrosecondType {
+    fn prop_ref(native: Self::Native, dtype: &DataType) -> PropRef<'static> {
+        match dtype {
+            DataType::Timestamp(_, tz) => match tz {
+                None => PropRef::from(DateTime::from_timestamp_micros(native).unwrap().naive_utc()),
+                Some(_) => PropRef::from(DateTime::from_timestamp_micros(native).unwrap()),
+            },
+            _ => unreachable!(),
+        }
+    }
+}
+
+impl DirectConvert for TimestampMillisecondType {
+    fn prop_ref(native: Self::Native, dtype: &DataType) -> PropRef<'static> {
+        match dtype {
+            DataType::Timestamp(_, tz) => match tz {
+                None => PropRef::from(DateTime::from_timestamp_millis(native).unwrap().naive_utc()),
+                Some(_) => PropRef::from(DateTime::from_timestamp_millis(native).unwrap()),
+            },
+            _ => unreachable!(),
+        }
+    }
+}
+
+impl DirectConvert for TimestampSecondType {
+    fn prop_ref(native: Self::Native, dtype: &DataType) -> PropRef<'static> {
+        match dtype {
+            DataType::Timestamp(_, tz) => match tz {
+                None => PropRef::from(DateTime::from_timestamp(native, 0).unwrap().naive_utc()),
+                Some(_) => PropRef::from(DateTime::from_timestamp(native, 0).unwrap()),
+            },
+            _ => unreachable!(),
+        }
+    }
+}
+
+impl DirectConvert for Decimal128Type {
+    fn prop_ref(native: Self::Native, dtype: &DataType) -> PropRef<'static> {
+        match dtype {
+            DataType::Decimal128(_, scale) => PropRef::Decimal {
+                num: native,
+                scale: *scale as i8,
+            },
+            _ => unreachable!(),
+        }
+    }
+}
diff --git a/raphtory-api/src/core/entities/properties/prop/mod.rs b/raphtory-api/src/core/entities/properties/prop/mod.rs
index 3b449d5059..4f563cdf57 100644
--- a/raphtory-api/src/core/entities/properties/prop/mod.rs
+++ b/raphtory-api/src/core/entities/properties/prop/mod.rs
@@ -1,6 +1,8 @@
-#[cfg(feature = "arrow")]
-mod prop_array;
+pub mod arrow;
+pub mod prop_array;
+pub mod prop_col;
 mod prop_enum;
+mod prop_ref_enum;
 mod prop_type;
 mod prop_unwrap;
 #[cfg(feature = "io")]
@@ -9,8 +11,10 @@ mod serde;
 #[cfg(feature = "template")]
 mod template;
 
-#[cfg(feature = "arrow")]
+pub use arrow::*;
+
 pub use prop_array::*;
 pub use prop_enum::*;
+pub use prop_ref_enum::*;
 pub use prop_type::*;
 pub use prop_unwrap::*;
diff --git a/raphtory-api/src/core/entities/properties/prop/prop_array.rs b/raphtory-api/src/core/entities/properties/prop/prop_array.rs
index 8ab7ee0676..e2489cb024 100644
--- a/raphtory-api/src/core/entities/properties/prop/prop_array.rs
+++ b/raphtory-api/src/core/entities/properties/prop/prop_array.rs
@@ -1,52 +1,62 @@
 use crate::{
-    core::entities::properties::prop::{Prop, PropType},
+    core::entities::properties::prop::{
+        unify_types, ArrowRow, DirectConvert, Prop, PropType, EMPTY_MAP_FIELD_NAME,
+    },
     iter::{BoxedLIter, IntoDynBoxed},
 };
 use arrow_array::{
-    cast::AsArray,
-    types::{
-        Float32Type, Float64Type, Int32Type, Int64Type, UInt16Type, UInt32Type, UInt64Type,
-        UInt8Type,
-    },
-    Array, ArrayRef, ArrowPrimitiveType, PrimitiveArray, RecordBatch,
+    cast::AsArray, types::*, Array, ArrayRef, ArrowPrimitiveType, OffsetSizeTrait, PrimitiveArray,
+    RecordBatch,
 };
-use arrow_ipc::{reader::StreamReader, writer::StreamWriter};
-use arrow_schema::{ArrowError, DataType, Field, Fields, Schema};
-use serde::{Deserialize, Serialize, Serializer};
+use arrow_ipc::{reader::FileReader, writer::FileWriter};
+use arrow_schema::{DataType, Field, Fields, Schema, TimeUnit};
+use serde::{de, ser, Deserialize, Deserializer, Serialize, Serializer};
 use std::{
     hash::{Hash, Hasher},
+    io::Cursor,
     sync::Arc,
 };
-use thiserror::Error;
 
-#[derive(Default, Debug, Clone)]
+#[derive(Debug, Clone, derive_more::From)]
 pub enum PropArray {
-    #[default]
-    Empty,
+    Vec(Arc<[Prop]>),
     Array(ArrayRef),
 }
 
-#[derive(Error, Debug)]
-pub enum DeserialisationError {
-    #[error("Failed to deserialize ArrayRef")]
-    DeserialisationError,
-    #[error(transparent)]
-    ArrowError(#[from] ArrowError),
+#[derive(Debug, Clone, Deserialize, Serialize)]
+enum SerializedPropArray {
+    Vec(Arc<[Prop]>),
+    Array(Vec<u8>),
+}
+
+impl Default for PropArray {
+    fn default() -> Self {
+        PropArray::Vec(vec![].into())
+    }
+}
+
+impl From<Vec<Prop>> for PropArray {
+    fn from(vec: Vec<Prop>) -> Self {
+        PropArray::Vec(Arc::from(vec))
+    }
 }
 
 impl Hash for PropArray {
     fn hash<H: Hasher>(&self, state: &mut H) {
-        if let PropArray::Array(array) = self {
-            let data = array.to_data();
-            let dtype = array.data_type();
-            dtype.hash(state);
-            data.offset().hash(state);
-            data.len().hash(state);
-            for buffer in data.buffers() {
-                buffer.hash(state);
+        match self {
+            PropArray::Array(array) => {
+                let data = array.to_data();
+                let dtype = array.data_type();
+                dtype.hash(state);
+                data.offset().hash(state);
+                data.len().hash(state);
+                for buffer in data.buffers() {
+                    buffer.hash(state);
+                }
+            }
+            PropArray::Vec(ps) => {
+                ps.hash(state);
             }
-        } else {
-            PropArray::Empty.hash(state);
         }
     }
 }
@@ -55,48 +65,32 @@ impl PropArray {
     pub fn len(&self) -> usize {
         match self {
             PropArray::Array(arr) => arr.len(),
-            PropArray::Empty => 0,
+            PropArray::Vec(ps) => ps.len(),
         }
     }
 
     pub fn is_empty(&self) -> bool {
         match self {
-            PropArray::Empty => true,
+            PropArray::Vec(ps) => ps.is_empty(),
             PropArray::Array(arr) => arr.is_empty(),
         }
     }
 
     pub fn dtype(&self) -> PropType {
         match self {
-            PropArray::Empty => PropType::Empty,
+            PropArray::Vec(ps) if ps.is_empty() => PropType::Empty,
+            PropArray::Vec(ps) => ps
+                .iter()
+                .map(|p| p.dtype())
+                .reduce(|dt1, dt2| {
+                    unify_types(&dt1, &dt2, &mut false)
+                        .unwrap_or_else(|e| panic!("Failed to unify props {e}"))
+                })
+                .unwrap(),
             PropArray::Array(a) => PropType::from(a.data_type()),
         }
     }
 
-    pub fn to_vec_u8(&self) -> Vec<u8> {
-        // assuming we can allocate this can't fail
-        let mut bytes = vec![];
-        if let PropArray::Array(value) = self {
-            let schema = Schema::new(vec![Field::new("data", value.data_type().clone(), true)]);
-            let mut writer = StreamWriter::try_new(&mut bytes, &schema).unwrap();
-            let rb = RecordBatch::try_new(schema.into(), vec![value.clone()]).unwrap();
-            writer.write(&rb).unwrap();
-            writer.finish().unwrap();
-        }
-        bytes
-    }
-
-    pub fn from_vec_u8(bytes: &[u8]) -> Result<Self, DeserialisationError> {
-        if bytes.is_empty() {
-            return Ok(PropArray::Empty);
-        }
-        let mut reader = StreamReader::try_new(bytes, None)?;
-        let rb = reader
-            .next()
-            .ok_or(DeserialisationError::DeserialisationError)??;
-        Ok(PropArray::Array(rb.column(0).clone()))
-    }
-
     pub fn into_array_ref(self) -> Option<ArrayRef> {
         match self {
             PropArray::Array(arr) => Some(arr),
@@ -111,97 +105,189 @@ impl PropArray {
         }
     }
 
-    pub fn iter_prop(&self) -> impl Iterator<Item = Prop> + '_ {
-        self.iter_prop_inner().into_iter().flatten()
+    // TODO: need something that returns PropRef instead to avoid allocations
+    pub fn iter(&self) -> impl Iterator<Item = Prop> + '_ {
+        self.iter_all().flatten()
     }
 
-    fn iter_prop_inner(&self) -> Option<BoxedLIter<'_, Prop>> {
-        let arr = self.as_array_ref()?;
+    pub fn iter_all(&self) -> BoxedLIter<'_, Option<Prop>> {
+        match self {
+            PropArray::Vec(ps) => ps.iter().cloned().map(Some).into_dyn_boxed(),
+            PropArray::Array(arr) => {
+                let dtype = arr.data_type();
+                match dtype {
+                    DataType::Boolean => arr
+                        .as_boolean()
+                        .iter()
+                        .map(|p| p.map(Prop::Bool))
+                        .into_dyn_boxed(),
+                    DataType::Int32 => as_primitive_iter::<Int32Type>(arr),
+                    DataType::Int64 => as_primitive_iter::<Int64Type>(arr),
+                    DataType::UInt8 => as_primitive_iter::<UInt8Type>(arr),
+                    DataType::UInt16 => as_primitive_iter::<UInt16Type>(arr),
+                    DataType::UInt32 => as_primitive_iter::<UInt32Type>(arr),
+                    DataType::UInt64 => as_primitive_iter::<UInt64Type>(arr),
+                    DataType::Float32 => as_primitive_iter::<Float32Type>(arr),
+                    DataType::Float64 => as_primitive_iter::<Float64Type>(arr),
+                    DataType::Timestamp(unit, _) => match unit {
+                        TimeUnit::Second => as_primitive_iter::<TimestampSecondType>(arr),
+                        TimeUnit::Millisecond => as_primitive_iter::<TimestampMillisecondType>(arr),
+                        TimeUnit::Microsecond => as_primitive_iter::<TimestampMicrosecondType>(arr),
+                        TimeUnit::Nanosecond => as_primitive_iter::<TimestampNanosecondType>(arr),
+                    },
+                    DataType::Date32 => as_primitive_iter::<Date32Type>(arr),
+                    DataType::Date64 => as_primitive_iter::<Date64Type>(arr),
+                    DataType::Utf8 | DataType::LargeUtf8 | DataType::Utf8View => as_str_iter(arr),
+                    DataType::Decimal128(_, _) => as_primitive_iter::<Decimal128Type>(arr),
+                    DataType::Struct(_) => as_struct_iter(arr),
+                    DataType::List(_) => as_list_iter::<i32>(arr),
+                    DataType::LargeList(_) => as_list_iter::<i64>(arr),
+                    _ => std::iter::empty().into_dyn_boxed(),
+                }
+            }
+        }
+    }
+}
 
-        arr.as_primitive_opt::<Int32Type>()
-            .map(|arr| {
-                arr.into_iter()
-                    .map(|v| Prop::I32(v.unwrap_or_default()))
-                    .into_dyn_boxed()
-            })
-            .or_else(|| {
-                arr.as_primitive_opt::<Float64Type>().map(|arr| {
-                    arr.into_iter()
-                        .map(|v| Prop::F64(v.unwrap_or_default()))
-                        .into_dyn_boxed()
-                })
-            })
-            .or_else(|| {
-                arr.as_primitive_opt::<Float32Type>().map(|arr| {
-                    arr.into_iter()
-                        .map(|v| Prop::F32(v.unwrap_or_default()))
-                        .into_dyn_boxed()
-                })
-            })
-            .or_else(|| {
-                arr.as_primitive_opt::<UInt64Type>().map(|arr| {
-                    arr.into_iter()
-                        .map(|v| Prop::U64(v.unwrap_or_default()))
-                        .into_dyn_boxed()
-                })
-            })
-            .or_else(|| {
-                arr.as_primitive_opt::<UInt32Type>().map(|arr| {
-                    arr.into_iter()
-                        .map(|v| Prop::U32(v.unwrap_or_default()))
-                        .into_dyn_boxed()
-                })
-            })
-            .or_else(|| {
-                arr.as_primitive_opt::<Int64Type>().map(|arr| {
-                    arr.into_iter()
-                        .map(|v| Prop::I64(v.unwrap_or_default()))
-                        .into_dyn_boxed()
-                })
-            })
-            .or_else(|| {
-                arr.as_primitive_opt::<UInt16Type>().map(|arr| {
-                    arr.into_iter()
-                        .map(|v| Prop::U16(v.unwrap_or_default()))
-                        .into_dyn_boxed()
-                })
-            })
-            .or_else(|| {
-                arr.as_primitive_opt::<UInt8Type>().map(|arr| {
-                    arr.into_iter()
-                        .map(|v| Prop::U8(v.unwrap_or_default()))
-                        .into_dyn_boxed()
-                })
-            })
+fn as_primitive_iter<TT: DirectConvert>(arr: &ArrayRef) -> BoxedLIter<'_, Option<Prop>> {
+    arr.as_primitive_opt::<TT>()
+        .into_iter()
+        .flat_map(|primitive_array| {
+            let dt = arr.data_type();
+            primitive_array.iter().map(|v| v.map(|v| TT::prop(v, dt)))
+        })
+        .into_dyn_boxed()
+}
+
+fn as_str_iter(arr: &ArrayRef) -> BoxedLIter<'_, Option<Prop>> {
+    match arr.data_type() {
+        DataType::Utf8 => arr
+            .as_string::<i32>()
+            .into_iter()
+            .map(|opt_str| opt_str.map(|s| Prop::str(s.to_string())))
+            .into_dyn_boxed(),
+        DataType::LargeUtf8 => arr
+            .as_string::<i64>()
+            .into_iter()
+            .map(|opt_str| opt_str.map(|s| Prop::str(s.to_string())))
+            .into_dyn_boxed(),
+        DataType::Utf8View => arr
+            .as_string_view()
+            .into_iter()
+            .map(|opt_str| opt_str.map(|s| Prop::str(s.to_string())))
+            .into_dyn_boxed(),
+        _ => panic!("as_str_iter called on non-string array"),
     }
 }
 
+fn as_struct_iter(arr: &ArrayRef) -> BoxedLIter<'_, Option<Prop>> {
+    let arr = arr.as_struct();
+    (0..arr.len())
+        .map(|row| (!arr.is_null(row)).then(|| ArrowRow::new(arr, row)))
+        .map(|arrow_row| arrow_row.and_then(|row| row.into_prop()))
+        .into_dyn_boxed()
+}
+
+fn as_list_iter<O: OffsetSizeTrait>(arr: &ArrayRef) -> BoxedLIter<'_, Option<Prop>> {
+    let arr = arr.as_list::<O>();
+    (0..arr.len())
+        .map(|i| {
+            if arr.is_null(i) {
+                None
+            } else {
+                let value_array = arr.value(i);
+                let prop_array = PropArray::Array(value_array);
+                Some(Prop::List(prop_array))
+            }
+        })
+        .into_dyn_boxed()
+}
+
 impl Serialize for PropArray {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
-        let bytes = self.to_vec_u8();
-        bytes.serialize(serializer)
+        let serializable = match self {
+            PropArray::Vec(inner) => SerializedPropArray::Vec(inner.clone()),
+            PropArray::Array(array) => {
+                let mut bytes = Vec::new();
+                let cursor = Cursor::new(&mut bytes);
+                let schema =
+                    Schema::new(vec![Field::new("value", array.data_type().clone(), true)]);
+                let mut writer = FileWriter::try_new(cursor, &schema)
+                    .map_err(|err| ser::Error::custom(err.to_string()))?;
+                let batch = RecordBatch::try_new(schema.into(), vec![array.clone()])
+                    .map_err(|err| ser::Error::custom(err.to_string()))?;
+                writer
+                    .write(&batch)
+                    .map_err(|err| ser::Error::custom(err.to_string()))?;
+                writer
+                    .finish()
+                    .map_err(|err| ser::Error::custom(err.to_string()))?;
+                SerializedPropArray::Array(bytes)
+            }
+        };
+        serializable.serialize(serializer)
     }
 }
 
 impl<'de> Deserialize<'de> for PropArray {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
-        D: serde::Deserializer<'de>,
+        D: Deserializer<'de>,
     {
-        let bytes = Vec::<u8>::deserialize(deserializer)?;
-        PropArray::from_vec_u8(&bytes).map_err(serde::de::Error::custom)
+        let data = SerializedPropArray::deserialize(deserializer)?;
+        let deserialized = match data {
+            SerializedPropArray::Vec(res) => PropArray::Vec(res),
+            SerializedPropArray::Array(bytes) => {
+                let cursor = Cursor::new(bytes);
+                let mut reader = FileReader::try_new(cursor, None)
+                    .map_err(|err| de::Error::custom(err.to_string()))?;
+                let batch = reader.next().ok_or_else(|| {
+                    de::Error::custom(
+                        "Failed to deserialize PropArray: Array data missing.".to_owned(),
+                    )
+                })?;
+                let batch = batch.map_err(|err| de::Error::custom(err.to_string()))?;
+                let (_, arrays, _) = batch.into_parts();
+                let array = arrays.into_iter().next().ok_or_else(|| {
+                    de::Error::custom(
+                        "Failed to deserialize PropArray: Array data missing.".to_owned(),
+                    )
+                })?;
+                PropArray::Array(array)
+            }
+        };
+        Ok(deserialized)
     }
 }
 
 impl PartialEq for PropArray {
     fn eq(&self, other: &Self) -> bool {
+        self.len() == other.len() && self.iter_all().eq(other.iter_all())
+    }
+}
+
+impl PartialOrd for PropArray {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
         match (self, other) {
-            (PropArray::Empty, PropArray::Empty) => true,
-            (PropArray::Array(a), PropArray::Array(b)) => a.eq(b),
-            _ => false,
+            (PropArray::Vec(l), PropArray::Vec(r)) => l.partial_cmp(r),
+            _ => {
+                let mut l_iter = self.iter_all();
+                let mut r_iter = other.iter_all();
+                loop {
+                    match (l_iter.next(), r_iter.next()) {
+                        (Some(lv), Some(rv)) => match lv.partial_cmp(&rv) {
+                            Some(std::cmp::Ordering::Equal) => continue,
+                            other => return other,
+                        },
+                        (None, None) => return Some(std::cmp::Ordering::Equal),
+                        (None, Some(_)) => return Some(std::cmp::Ordering::Less),
+                        (Some(_), None) => return Some(std::cmp::Ordering::Greater),
+                    }
+                }
+            }
         }
     }
 }
@@ -212,13 +298,13 @@ impl Prop {
         PrimitiveArray<TT>: From<Vec<TT::Native>>,
     {
         let array = PrimitiveArray::<TT>::from(vals);
-        Prop::Array(PropArray::Array(Arc::new(array)))
+        Prop::List(PropArray::Array(Arc::new(array)))
     }
 }
 
 pub fn arrow_dtype_from_prop_type(prop_type: &PropType) -> DataType {
     match prop_type {
-        PropType::Str => DataType::LargeUtf8,
+        PropType::Str => DataType::Utf8View,
         PropType::U8 => DataType::UInt8,
         PropType::U16 => DataType::UInt16,
         PropType::I32 => DataType::Int32,
@@ -232,12 +318,8 @@ pub fn arrow_dtype_from_prop_type(prop_type: &PropType) -> DataType {
         PropType::DTime => {
             DataType::Timestamp(arrow_schema::TimeUnit::Millisecond, Some("UTC".into()))
         }
-        PropType::Array(d_type) => {
-            DataType::List(Field::new("data", arrow_dtype_from_prop_type(d_type), true).into())
-        }
-
         PropType::List(d_type) => {
-            DataType::List(Field::new("data", arrow_dtype_from_prop_type(d_type), true).into())
+            DataType::LargeList(Field::new("data", arrow_dtype_from_prop_type(d_type), true).into())
         }
         PropType::Map(d_type) => {
             let fields = d_type
@@ -246,7 +328,7 @@ pub fn arrow_dtype_from_prop_type(prop_type: &PropType) -> DataType {
                 .collect::<Vec<_>>();
             if fields.is_empty() {
                 DataType::Struct(Fields::from_iter([Field::new(
-                    "__empty__",
+                    EMPTY_MAP_FIELD_NAME,
                     DataType::Null,
                     true,
                 )]))
@@ -263,29 +345,6 @@ pub fn arrow_dtype_from_prop_type(prop_type: &PropType) -> DataType {
     }
 }
 
-pub fn prop_type_from_arrow_dtype(arrow_dtype: &DataType) -> PropType {
-    match arrow_dtype {
-        DataType::LargeUtf8 | DataType::Utf8 | DataType::Utf8View => PropType::Str,
-        DataType::UInt8 => PropType::U8,
-        DataType::UInt16 => PropType::U16,
-        DataType::Int32 => PropType::I32,
-        DataType::Int64 => PropType::I64,
-        DataType::UInt32 => PropType::U32,
-        DataType::UInt64 => PropType::U64,
-        DataType::Float32 => PropType::F32,
-        DataType::Float64 => PropType::F64,
-        DataType::Boolean => PropType::Bool,
-        DataType::Decimal128(_, scale) => PropType::Decimal {
-            scale: *scale as i64,
-        },
-        DataType::List(field) => {
-            let d_type = field.data_type();
-            PropType::Array(Box::new(prop_type_from_arrow_dtype(d_type)))
-        }
-        _ => panic!("{:?} not supported as disk_graph property", arrow_dtype),
-    }
-}
-
 pub trait PropArrayUnwrap: Sized {
     fn into_array(self) -> Option<ArrayRef>;
     fn unwrap_array(self) -> ArrayRef {
@@ -301,10 +360,35 @@ impl<P: PropArrayUnwrap> PropArrayUnwrap for Option<P> {
 
 impl PropArrayUnwrap for Prop {
     fn into_array(self) -> Option<ArrayRef> {
-        if let Prop::Array(v) = self {
+        if let Prop::List(v) = self {
             v.into_array_ref()
         } else {
             None
         }
     }
 }
+
+#[cfg(test)]
+mod test {
+    use crate::core::entities::properties::prop::{Prop, PropArray};
+    use arrow_array::Int64Array;
+    use std::sync::Arc;
+
+    #[test]
+    fn test_prop_array_json() {
+        let array = PropArray::Array(Arc::new(Int64Array::from(vec![0, 1, 2])));
+        let json = serde_json::to_string(&array).unwrap();
+        println!("{json}");
+        let recovered: PropArray = serde_json::from_str(&json).unwrap();
+        assert_eq!(array, recovered);
+    }
+
+    #[test]
+    fn test_prop_array_list_json() {
+        let array = PropArray::Vec([Prop::U64(1), Prop::U64(2)].into());
+        let json = serde_json::to_string(&array).unwrap();
+        println!("{json}");
+        let recovered: PropArray = serde_json::from_str(&json).unwrap();
+        assert_eq!(array, recovered);
+    }
+}
diff --git a/raphtory-api/src/core/entities/properties/prop/prop_col.rs b/raphtory-api/src/core/entities/properties/prop/prop_col.rs
new file mode 100644
index 0000000000..aaff467cca
--- /dev/null
+++ b/raphtory-api/src/core/entities/properties/prop/prop_col.rs
@@ -0,0 +1,622 @@
+use crate::{
+    core::{
+        entities::properties::prop::{IntoPropList, Prop, PropArray, PropMapRef, PropNum, PropRef},
+        storage::arc_str::ArcStr,
+    },
+    iter::IntoDynBoxed,
+};
+use arrow_array::{
+    cast::AsArray,
+    types::{
+        Date32Type, Date64Type, Decimal128Type, Float32Type, Float64Type, Int32Type, Int64Type,
+        TimestampMicrosecondType, TimestampMillisecondType, TimestampNanosecondType,
+        TimestampSecondType, UInt16Type, UInt32Type, UInt64Type, UInt8Type,
+    },
+    Array, ArrayRef, ArrowPrimitiveType, BooleanArray, Decimal128Array, FixedSizeListArray,
+    GenericListArray, GenericStringArray, NullArray, OffsetSizeTrait, PrimitiveArray,
+    StringViewArray, StructArray,
+};
+use arrow_buffer::NullBuffer;
+use arrow_schema::{DataType, Field, TimeUnit};
+use bigdecimal::BigDecimal;
+use chrono::{DateTime, Utc};
+use rustc_hash::FxHashMap;
+use std::{borrow::Cow, sync::Arc};
+
+pub trait PropCol: Send + Sync + std::fmt::Debug {
+    fn get(&self, i: usize) -> Option<Prop>;
+
+    fn get_ref(&self, i: usize) -> Option<PropRef<'_>>;
+
+    fn as_array(&self) -> ArrayRef;
+
+    fn iter(&self) -> Box<dyn Iterator<Item = Option<Prop>> + '_> {
+        (0..self.as_array().len())
+            .map(move |i| self.get(i))
+            .into_dyn_boxed()
+    }
+
+    fn iter_ref(&self) -> Box<dyn Iterator<Item = Option<PropRef<'_>>> + '_> {
+        (0..self.as_array().len())
+            .map(move |i| self.get_ref(i))
+            .into_dyn_boxed()
+    }
+}
+
+#[derive(Debug)]
+pub struct MapCol {
+    validity: Option<NullBuffer>,
+    values: Vec<(String, Box<dyn PropCol>)>,
+}
+
+impl MapCol {
+    fn new(arr: &StructArray) -> Self {
+        let validity = arr.nulls().cloned();
+        let values = arr
+            .fields()
+            .iter()
+            .zip(arr.columns())
+            .map(|(field, col)| (field.name().clone(), lift_property_col(col.as_ref())))
+            .collect();
+        Self { validity, values }
+    }
+}
+impl PropCol for MapCol {
+    fn get(&self, i: usize) -> Option<Prop> {
+        if self
+            .validity
+            .as_ref()
+            .is_none_or(|validity| validity.is_valid(i))
+        {
+            Some(Prop::map(self.values.iter().filter_map(|(field, col)| {
+                Some((field.as_str(), col.get(i)?))
+            })))
+        } else {
+            None
+        }
+    }
+
+    fn get_ref(&self, i: usize) -> Option<PropRef<'_>> {
+        if self
+            .validity
+            .as_ref()
+            .is_none_or(|validity| validity.is_valid(i))
+        {
+            Some(PropRef::Map(PropMapRef::PropCol { map: self, i }))
+        } else {
+            None
+        }
+    }
+
+    fn as_array(&self) -> ArrayRef {
+        let fields = self
+            .values
+            .iter()
+            .map(|(name, col)| Field::new(name, col.as_array().data_type().clone(), true))
+            .collect::<Vec<_>>();
+        let columns = self.values.iter().map(|(_, col)| col.as_array()).collect();
+        Arc::new(StructArray::new(
+            fields.into(),
+            columns,
+            self.validity.clone(),
+        ))
+    }
+}
+
+impl PropCol for BooleanArray {
+    fn get(&self, i: usize) -> Option<Prop> {
+        if self.is_null(i) || self.len() <= i {
+            None
+        } else {
+            Some(Prop::Bool(self.value(i)))
+        }
+    }
+
+    fn get_ref(&self, i: usize) -> Option<PropRef<'_>> {
+        if self.is_null(i) || self.len() <= i {
+            None
+        } else {
+            Some(PropRef::Bool(self.value(i)))
+        }
+    }
+
+    fn as_array(&self) -> ArrayRef {
+        Arc::new(self.clone())
+    }
+
+    fn iter(&self) -> Box<dyn Iterator<Item = Option<Prop>> + '_> {
+        self.iter().map(|opt| opt.map(Prop::Bool)).into_dyn_boxed()
+    }
+}
+
+impl<T: ArrowPrimitiveType> PropCol for PrimitiveArray<T>
+where
+    T::Native: Into<Prop> + Into<PropNum>,
+{
+    fn get(&self, i: usize) -> Option<Prop> {
+        if self.is_null(i) || self.len() <= i {
+            None
+        } else {
+            Some(self.value(i).into())
+        }
+    }
+
+    fn get_ref(&self, i: usize) -> Option<PropRef<'_>> {
+        if self.is_null(i) || self.len() <= i {
+            None
+        } else {
+            Some(PropRef::Num(self.value(i).into()))
+        }
+    }
+
+    fn as_array(&self) -> ArrayRef {
+        Arc::new(self.clone())
+    }
+
+    fn iter(&self) -> Box<dyn Iterator<Item = Option<Prop>> + '_> {
+        self.iter()
+            .map(|opt| opt.map(|v| v.into()))
+            .into_dyn_boxed()
+    }
+}
+
+impl<I: OffsetSizeTrait> PropCol for GenericStringArray<I> {
+    fn get(&self, i: usize) -> Option<Prop> {
+        if self.is_null(i) || self.len() <= i {
+            None
+        } else {
+            Some(Prop::str(self.value(i)))
+        }
+    }
+
+    fn get_ref(&self, i: usize) -> Option<PropRef<'_>> {
+        if self.is_null(i) || self.len() <= i {
+            None
+        } else {
+            Some(PropRef::Str(self.value(i)))
+        }
+    }
+    fn as_array(&self) -> ArrayRef {
+        Arc::new(self.clone())
+    }
+
+    fn iter(&self) -> Box<dyn Iterator<Item = Option<Prop>> + '_> {
+        self.iter().map(|opt| opt.map(Prop::str)).into_dyn_boxed()
+    }
+}
+
+impl PropCol for StringViewArray {
+    fn get(&self, i: usize) -> Option<Prop> {
+        if self.is_null(i) || self.len() <= i {
+            None
+        } else {
+            Some(Prop::str(self.value(i)))
+        }
+    }
+
+    fn get_ref(&self, i: usize) -> Option<PropRef<'_>> {
+        if self.is_null(i) || self.len() <= i {
+            None
+        } else {
+            Some(PropRef::Str(self.value(i)))
+        }
+    }
+    fn as_array(&self) -> ArrayRef {
+        Arc::new(self.clone())
+    }
+
+    fn iter(&self) -> Box<dyn Iterator<Item = Option<Prop>> + '_> {
+        self.iter().map(|opt| opt.map(Prop::str)).into_dyn_boxed()
+    }
+}
+
+impl<I: OffsetSizeTrait> PropCol for GenericListArray<I> {
+    fn get(&self, i: usize) -> Option<Prop> {
+        if i >= self.len() || self.is_null(i) {
+            None
+        } else {
+            Some(arr_as_prop(self.value(i)))
+        }
+    }
+
+    fn get_ref(&self, i: usize) -> Option<PropRef<'_>> {
+        if self.is_null(i) || self.len() <= i {
+            None
+        } else {
+            Some(PropRef::List(Cow::Owned(self.value(i).into())))
+        }
+    }
+    fn as_array(&self) -> ArrayRef {
+        Arc::new(self.clone())
+    }
+}
+
+impl PropCol for FixedSizeListArray {
+    fn get(&self, i: usize) -> Option<Prop> {
+        if i >= self.len() || self.is_null(i) {
+            None
+        } else {
+            Some(arr_as_prop(self.value(i)))
+        }
+    }
+
+    fn get_ref(&self, i: usize) -> Option<PropRef<'_>> {
+        if self.is_null(i) || self.len() <= i {
+            None
+        } else {
+            Some(PropRef::List(Cow::Owned(self.value(i).into())))
+        }
+    }
+    fn as_array(&self) -> ArrayRef {
+        Arc::new(self.clone())
+    }
+}
+
+impl PropCol for NullArray {
+    fn get(&self, _i: usize) -> Option<Prop> {
+        None
+    }
+
+    fn get_ref(&self, _i: usize) -> Option<PropRef<'_>> {
+        None
+    }
+    fn as_array(&self) -> ArrayRef {
+        Arc::new(self.clone())
+    }
+}
+
+#[derive(Debug)]
+struct MappedPrimitiveCol<T: ArrowPrimitiveType> {
+    arr: PrimitiveArray<T>,
+    map: fn(T::Native) -> PropRef<'static>,
+}
+
+impl<T: ArrowPrimitiveType + std::fmt::Debug> PropCol for MappedPrimitiveCol<T> {
+    fn get(&self, i: usize) -> Option<Prop> {
+        self.get_ref(i).map(|p_ref| p_ref.into())
+    }
+
+    fn get_ref(&self, i: usize) -> Option<PropRef<'_>> {
+        if i >= self.arr.len() || self.arr.is_null(i) {
+            None
+        } else {
+            Some((self.map)(self.arr.value(i)))
+        }
+    }
+
+    fn as_array(&self) -> ArrayRef {
+        Arc::new(self.arr.clone())
+    }
+}
+
+#[derive(Debug)]
+struct DecimalPropCol {
+    arr: Decimal128Array,
+    scale: i64,
+}
+
+impl PropCol for DecimalPropCol {
+    fn get(&self, i: usize) -> Option<Prop> {
+        if i >= self.arr.len() || self.arr.is_null(i) {
+            None
+        } else {
+            Some(Prop::Decimal(BigDecimal::new(
+                self.arr.value(i).into(),
+                self.scale,
+            )))
+        }
+    }
+
+    fn get_ref(&self, i: usize) -> Option<PropRef<'_>> {
+        if i >= self.arr.len() || self.arr.is_null(i) {
+            None
+        } else {
+            Some(PropRef::Decimal {
+                num: self.arr.value(i).into(),
+                scale: self.scale as i8,
+            })
+        }
+    }
+
+    fn as_array(&self) -> ArrayRef {
+        Arc::new(self.arr.clone())
+    }
+}
+
+#[derive(Debug)]
+struct EmptyCol;
+
+impl PropCol for EmptyCol {
+    fn get(&self, _i: usize) -> Option<Prop> {
+        None
+    }
+
+    fn get_ref(&self, _i: usize) -> Option<PropRef<'_>> {
+        None
+    }
+
+    fn as_array(&self) -> ArrayRef {
+        Arc::new(NullArray::new(0))
+    }
+}
+pub fn lift_property_col(arr: &dyn Array) -> Box<dyn PropCol> {
+    match arr.data_type() {
+        DataType::Boolean => Box::new(arr.as_boolean().clone()),
+        DataType::Int32 => Box::new(arr.as_primitive::<Int32Type>().clone()),
+        DataType::Int64 => Box::new(arr.as_primitive::<Int64Type>().clone()),
+        DataType::UInt8 => Box::new(arr.as_primitive::<UInt8Type>().clone()),
+        DataType::UInt16 => Box::new(arr.as_primitive::<UInt16Type>().clone()),
+        DataType::UInt32 => Box::new(arr.as_primitive::<UInt32Type>().clone()),
+        DataType::UInt64 => Box::new(arr.as_primitive::<UInt64Type>().clone()),
+        DataType::Float32 => Box::new(arr.as_primitive::<Float32Type>().clone()),
+        DataType::Float64 => Box::new(arr.as_primitive::<Float64Type>().clone()),
+        DataType::Utf8 => Box::new(arr.as_string::<i32>().clone()),
+        DataType::LargeUtf8 => Box::new(arr.as_string::<i64>().clone()),
+        DataType::Utf8View => Box::new(arr.as_string_view().clone()),
+        DataType::List(_) => Box::new(arr.as_list::<i32>().clone()),
+        DataType::LargeList(_) => Box::new(arr.as_list::<i64>().clone()),
+        DataType::FixedSizeList(_, _) => Box::new(arr.as_fixed_size_list().clone()),
+        DataType::Struct(_) => Box::new(MapCol::new(arr.as_struct())),
+        DataType::Timestamp(timeunit, timezone) => match timezone {
+            Some(_) => match timeunit {
+                TimeUnit::Second => Box::new(MappedPrimitiveCol {
+                    arr: arr.as_primitive::<TimestampSecondType>().clone(),
+                    map: |v| {
+                        PropRef::DTime(
+                            DateTime::<Utc>::from_timestamp(v, 0)
+                                .expect("DateTime conversion failed"),
+                        )
+                    },
+                }),
+                TimeUnit::Millisecond => Box::new(MappedPrimitiveCol {
+                    arr: arr.as_primitive::<TimestampMillisecondType>().clone(),
+                    map: |v| {
+                        PropRef::DTime(
+                            DateTime::<Utc>::from_timestamp_millis(v)
+                                .expect("DateTime conversion failed"),
+                        )
+                    },
+                }),
+                TimeUnit::Microsecond => Box::new(MappedPrimitiveCol {
+                    arr: arr.as_primitive::<TimestampMicrosecondType>().clone(),
+                    map: |v| {
+                        PropRef::DTime(
+                            DateTime::<Utc>::from_timestamp_micros(v)
+                                .expect("DateTime conversion failed"),
+                        )
+                    },
+                }),
+                TimeUnit::Nanosecond => Box::new(MappedPrimitiveCol {
+                    arr: arr.as_primitive::<TimestampNanosecondType>().clone(),
+                    map: |v| PropRef::DTime(DateTime::<Utc>::from_timestamp_nanos(v)),
+                }),
+            },
+            None => match timeunit {
+                TimeUnit::Second => Box::new(MappedPrimitiveCol {
+                    arr: arr.as_primitive::<TimestampSecondType>().clone(),
+                    map: |v| {
+                        PropRef::NDTime(
+                            DateTime::from_timestamp(v, 0)
+                                .expect("DateTime conversion failed")
+                                .naive_utc(),
+                        )
+                    },
+                }),
+                TimeUnit::Millisecond => Box::new(MappedPrimitiveCol {
+                    arr: arr.as_primitive::<TimestampMillisecondType>().clone(),
+                    map: |v| {
+                        PropRef::NDTime(
+                            DateTime::from_timestamp_millis(v)
+                                .expect("DateTime conversion failed")
+                                .naive_utc(),
+                        )
+                    },
+                }),
+                TimeUnit::Microsecond => Box::new(MappedPrimitiveCol {
+                    arr: arr.as_primitive::<TimestampMicrosecondType>().clone(),
+                    map: |v| {
+                        PropRef::NDTime(
+                            DateTime::from_timestamp_micros(v)
+                                .expect("DateTime conversion failed")
+                                .naive_utc(),
+                        )
+                    },
+                }),
+                TimeUnit::Nanosecond => Box::new(MappedPrimitiveCol {
+                    arr: arr.as_primitive::<TimestampNanosecondType>().clone(),
+                    map: |v| PropRef::NDTime(DateTime::from_timestamp_nanos(v).naive_utc()),
+                }),
+            },
+        },
+        DataType::Date32 => Box::new(MappedPrimitiveCol {
+            arr: arr.as_primitive::<Date32Type>().clone(),
+            map: |days| {
+                let ms = (days as i64) * 86_400_000; // convert days to ms
+                PropRef::NDTime(
+                    DateTime::from_timestamp_millis(ms)
+                        .expect("DateTime conversion failed for Date32 type")
+                        .naive_utc(),
+                )
+            },
+        }),
+        DataType::Date64 => Box::new(MappedPrimitiveCol {
+            arr: arr.as_primitive::<Date64Type>().clone(),
+            map: |ms| {
+                PropRef::NDTime(
+                    DateTime::from_timestamp_millis(ms)
+                        .expect("DateTime conversion failed for Date64 type")
+                        .naive_utc(),
+                )
+            },
+        }),
+        DataType::Decimal128(precision, scale) if *precision <= 38 => {
+            let arr = arr.as_primitive::<Decimal128Type>().clone();
+            Box::new(DecimalPropCol {
+                arr,
+                scale: *scale as i64,
+            })
+        }
+        DataType::Null => Box::new(EmptyCol),
+
+        unsupported => panic!("Data type not supported: {:?}", unsupported),
+    }
+}
+fn arr_as_prop(arr: ArrayRef) -> Prop {
+    match arr.data_type() {
+        DataType::Boolean => {
+            let arr = arr.as_boolean();
+            arr.iter().flatten().into_prop_list()
+        }
+        DataType::Int32 => {
+            let arr = arr.as_primitive::<Int32Type>();
+            arr.iter().flatten().into_prop_list()
+        }
+        DataType::Int64 => {
+            let arr = arr.as_primitive::<Int64Type>();
+            arr.iter().flatten().into_prop_list()
+        }
+        DataType::UInt8 => {
+            let arr = arr.as_primitive::<UInt8Type>();
+            arr.iter().flatten().into_prop_list()
+        }
+        DataType::UInt16 => {
+            let arr = arr.as_primitive::<UInt16Type>();
+            arr.iter().flatten().into_prop_list()
+        }
+        DataType::UInt32 => {
+            let arr = arr.as_primitive::<UInt32Type>();
+            arr.iter().flatten().into_prop_list()
+        }
+        DataType::UInt64 => {
+            let arr = arr.as_primitive::<UInt64Type>();
+            arr.iter().flatten().into_prop_list()
+        }
+        DataType::Float32 => {
+            let arr = arr.as_primitive::<Float32Type>();
+            arr.iter().flatten().into_prop_list()
+        }
+        DataType::Float64 => {
+            let arr = arr.as_primitive::<Float64Type>();
+            arr.iter().flatten().into_prop_list()
+        }
+        DataType::Utf8 => {
+            let arr = arr.as_string::<i32>();
+            arr.iter().flatten().into_prop_list()
+        }
+        DataType::LargeUtf8 => {
+            let arr = arr.as_string::<i64>();
+            arr.iter().flatten().into_prop_list()
+        }
+        DataType::Utf8View => {
+            let arr = arr.as_string_view();
+            arr.iter().flatten().into_prop_list()
+        }
+        DataType::List(_) => {
+            let arr = arr.as_list::<i32>();
+            arr.iter().flatten().map(arr_as_prop).into_prop_list()
+        }
+        DataType::FixedSizeList(_, _) => {
+            let arr = arr.as_fixed_size_list();
+            arr.iter().flatten().map(arr_as_prop).into_prop_list()
+        }
+        DataType::LargeList(_) => {
+            let arr = arr.as_list::<i64>();
+            arr.iter().flatten().map(arr_as_prop).into_prop_list()
+        }
+        DataType::Timestamp(TimeUnit::Second, tz) => {
+            let map_fn = if tz.is_some() {
+                |elem: i64| Prop::DTime(DateTime::<Utc>::from_timestamp_secs(elem).unwrap())
+            } else {
+                |elem: i64| Prop::NDTime(DateTime::from_timestamp_secs(elem).unwrap().naive_utc())
+            };
+            let arr = arr.as_primitive::<TimestampSecondType>();
+            arr.iter().flatten().map(map_fn).into_prop_list()
+        }
+        DataType::Timestamp(TimeUnit::Millisecond, tz) => {
+            let map_fn = if tz.is_some() {
+                |elem: i64| Prop::DTime(DateTime::<Utc>::from_timestamp_millis(elem).unwrap())
+            } else {
+                |elem: i64| Prop::NDTime(DateTime::from_timestamp_millis(elem).unwrap().naive_utc())
+            };
+            let arr = arr.as_primitive::<TimestampMillisecondType>();
+            arr.iter().flatten().map(map_fn).into_prop_list()
+        }
+        DataType::Timestamp(TimeUnit::Microsecond, tz) => {
+            let map_fn = if tz.is_some() {
+                |elem: i64| Prop::DTime(DateTime::<Utc>::from_timestamp_micros(elem).unwrap())
+            } else {
+                |elem: i64| Prop::NDTime(DateTime::from_timestamp_micros(elem).unwrap().naive_utc())
+            };
+            let arr = arr.as_primitive::<TimestampMicrosecondType>();
+            arr.iter().flatten().map(map_fn).into_prop_list()
+        }
+        DataType::Timestamp(TimeUnit::Nanosecond, tz) => {
+            let map_fn = if tz.is_some() {
+                |elem: i64| Prop::DTime(DateTime::<Utc>::from_timestamp_nanos(elem))
+            } else {
+                |elem: i64| Prop::NDTime(DateTime::from_timestamp_nanos(elem).naive_utc())
+            };
+            let arr = arr.as_primitive::<TimestampNanosecondType>();
+            arr.iter().flatten().map(map_fn).into_prop_list()
+        }
+        DataType::Date32 => {
+            let arr = arr.as_primitive::<Date32Type>();
+            arr.iter()
+                .flatten()
+                .map(|days| {
+                    let ms = (days as i64) * 86_400_000;
+                    Prop::NDTime(
+                        DateTime::from_timestamp_millis(ms)
+                            .expect("DateTime conversion failed for Date32 type")
+                            .naive_utc(),
+                    )
+                })
+                .into_prop_list()
+        }
+        DataType::Date64 => {
+            let arr = arr.as_primitive::<Date64Type>();
+            arr.iter()
+                .flatten()
+                .map(|ms| {
+                    Prop::NDTime(
+                        DateTime::from_timestamp_millis(ms)
+                            .expect("DateTime conversion failed for Date64 type")
+                            .naive_utc(),
+                    )
+                })
+                .into_prop_list()
+        }
+        DataType::Struct(_) => {
+            let arr = arr.as_struct();
+            let cols = arr
+                .columns()
+                .iter()
+                .map(|arr| lift_property_col(arr.as_ref()))
+                .collect::<Vec<_>>();
+
+            let mut props = Vec::with_capacity(arr.len());
+            for i in 0..arr.len() {
+                let fields = cols
+                    .iter()
+                    .zip(arr.fields())
+                    .filter_map(|(col, field)| {
+                        col.get(i)
+                            .map(|prop| (ArcStr::from(field.name().as_str()), prop))
+                    })
+                    .collect::<FxHashMap<_, _>>();
+                props.push(Prop::Map(fields.into()));
+            }
+
+            props.into_prop_list()
+        }
+        DataType::Decimal128(precision, scale) if *precision <= 38 => {
+            let arr = arr.as_primitive::<Decimal128Type>();
+            arr.iter()
+                .flatten()
+                .map(|elem| Prop::Decimal(BigDecimal::new(elem.into(), *scale as i64)))
+                .into_prop_list()
+        }
+        DataType::Null => Prop::List(PropArray::default()),
+        dt => panic!("Data type not recognized {dt:?}"),
+    }
+}
diff --git a/raphtory-api/src/core/entities/properties/prop/prop_enum.rs b/raphtory-api/src/core/entities/properties/prop/prop_enum.rs
index 9fcae4b9a5..05ac89825d 100644
--- a/raphtory-api/src/core/entities/properties/prop/prop_enum.rs
+++ b/raphtory-api/src/core/entities/properties/prop/prop_enum.rs
@@ -1,24 +1,40 @@
-use crate::core::{entities::properties::prop::PropType, storage::arc_str::ArcStr};
+use crate::core::{
+    entities::{
+        properties::prop::{prop_array::*, prop_ref_enum::PropRef, ArrowRow, PropNum, PropType},
+        GidRef,
+    },
+    storage::arc_str::ArcStr,
+};
+use arrow_array::{
+    cast::AsArray,
+    types::{
+        Date32Type, Date64Type, Decimal128Type, DecimalType, Float32Type, Float64Type, Int32Type,
+        Int64Type, TimestampMicrosecondType, TimestampMillisecondType, TimestampNanosecondType,
+        TimestampSecondType, UInt16Type, UInt32Type, UInt64Type, UInt8Type,
+    },
+    Array, ArrayRef, LargeListArray, StructArray,
+};
+use arrow_schema::{DataType, Field, FieldRef, TimeUnit};
 use bigdecimal::{num_bigint::BigInt, BigDecimal};
 use chrono::{DateTime, NaiveDateTime, Utc};
 use itertools::Itertools;
 use num_traits::{Bounded, FromPrimitive, ToPrimitive};
-use rustc_hash::FxHashMap;
-use serde::{Deserialize, Serialize};
+use rustc_hash::{FxBuildHasher, FxHashMap};
+use serde::{
+    ser::{Error, SerializeMap, SerializeSeq},
+    Deserialize, Serialize, Serializer,
+};
 use std::{
     cmp::Ordering,
     collections::HashMap,
     fmt,
-    fmt::{Display, Error, Formatter},
-    hash::{Hash, Hasher},
+    fmt::{Display, Formatter},
+    hash::{DefaultHasher, Hash, Hasher},
+    num::Wrapping,
     sync::Arc,
 };
 use thiserror::Error;
 
-#[cfg(feature = "arrow")]
-use crate::core::entities::properties::prop::prop_array::*;
-use crate::core::entities::properties::prop::unify_types;
-
 pub const DECIMAL_MAX: i128 = 99999999999999999999999999999999999999i128; // equivalent to parquet decimal(38, 0)
 
 #[derive(Error, Debug)]
@@ -43,9 +59,7 @@ enum PropUntaggedDef {
     F64(f64),
     F32(f32),
     Bool(bool),
-    #[cfg(feature = "arrow")]
-    Array(PropArray),
-    List(Arc<Vec<Prop>>),
+    List(PropArray),
     Map(Arc<FxHashMap<ArcStr, Prop>>),
     NDTime(NaiveDateTime),
     DTime(DateTime<Utc>),
@@ -101,9 +115,7 @@ impl<'de> Deserialize<'de> for PropUntagged {
             PropUntaggedHelper::F64(v) => Prop::F64(v),
             PropUntaggedHelper::F32(v) => Prop::F32(v),
             PropUntaggedHelper::Str(v) => Prop::Str(v),
-            PropUntaggedHelper::List(v) => {
-                Prop::List(Arc::new(v.into_iter().map(|p| p.0).collect()))
-            }
+            PropUntaggedHelper::List(v) => Prop::list(v),
             PropUntaggedHelper::Map(v) => {
                 Prop::Map(Arc::new(v.into_iter().map(|(k, p)| (k, p.0)).collect()))
             }
@@ -125,7 +137,7 @@ impl PartialEq<Prop> for PropUntagged {
 }
 
 /// Denotes the types of properties allowed to be stored in the graph.
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, derive_more::From)]
 pub enum Prop {
     Str(ArcStr),
     U8(u8),
@@ -137,15 +149,50 @@ pub enum Prop {
     F64(f64),
     F32(f32),
     Bool(bool),
-    #[cfg(feature = "arrow")]
-    Array(PropArray),
-    List(Arc<Vec<Prop>>),
+    List(PropArray),
     Map(Arc<FxHashMap<ArcStr, Prop>>),
     NDTime(NaiveDateTime),
     DTime(DateTime<Utc>),
     Decimal(BigDecimal),
 }
 
+impl From<GidRef<'_>> for Prop {
+    fn from(value: GidRef<'_>) -> Self {
+        match value {
+            GidRef::U64(n) => Prop::U64(n),
+            GidRef::Str(s) => Prop::str(s),
+        }
+    }
+}
+
+impl<'a> From<PropRef<'a>> for Prop {
+    fn from(value: PropRef<'a>) -> Self {
+        match value {
+            PropRef::Str(s) => Prop::Str(s.into()),
+            PropRef::Num(n) => match n {
+                PropNum::U8(u) => Prop::U8(u),
+                PropNum::U16(u) => Prop::U16(u),
+                PropNum::I32(i) => Prop::I32(i),
+                PropNum::I64(i) => Prop::I64(i),
+                PropNum::U32(u) => Prop::U32(u),
+                PropNum::U64(u) => Prop::U64(u),
+                PropNum::F32(f) => Prop::F32(f),
+                PropNum::F64(f) => Prop::F64(f),
+            },
+            PropRef::Bool(b) => Prop::Bool(b),
+            PropRef::List(v) => Prop::List(v.as_ref().clone()),
+            PropRef::Map(m) => m
+                .into_prop()
+                .unwrap_or_else(|| Prop::Map(Arc::new(Default::default()))),
+            PropRef::NDTime(dt) => Prop::NDTime(dt),
+            PropRef::DTime(dt) => Prop::DTime(dt),
+            PropRef::Decimal { num, scale } => {
+                Prop::Decimal(BigDecimal::from_bigint(num.into(), scale as i64))
+            }
+        }
+    }
+}
+
 impl Hash for Prop {
     fn hash<H: Hasher>(&self, state: &mut H) {
         match self {
@@ -166,8 +213,6 @@ impl Hash for Prop {
             }
             Prop::Bool(b) => b.hash(state),
             Prop::NDTime(dt) => dt.hash(state),
-            #[cfg(feature = "arrow")]
-            Prop::Array(b) => b.hash(state),
             Prop::DTime(dt) => dt.hash(state),
             Prop::List(v) => {
                 for prop in v.iter() {
@@ -175,10 +220,20 @@ impl Hash for Prop {
                 }
             }
             Prop::Map(m) => {
-                for (key, prop) in m.iter() {
-                    key.hash(state);
-                    prop.hash(state);
+                // Based on python set hash
+                let mut hash = Wrapping(1927868237u64);
+                hash *= (m.len() as u64).wrapping_add(1);
+                for v in m.iter() {
+                    let mut inner_hasher = DefaultHasher::new();
+                    v.hash(&mut inner_hasher);
+                    let inner_hash = Wrapping(inner_hasher.finish());
+                    hash ^= (inner_hash ^ (inner_hash << 16) ^ Wrapping(89869747u64))
+                        * Wrapping(3644798167u64);
                 }
+                hash ^= (hash >> 11) ^ (hash >> 25);
+                hash *= 69069;
+                hash += 907133923;
+                state.write_u64(hash.0);
             }
             Prop::Decimal(d) => d.hash(state),
         }
@@ -209,150 +264,289 @@ impl PartialOrd for Prop {
     }
 }
 
-pub fn validate_prop(prop: Prop) -> Result<Prop, InvalidBigDecimal> {
-    match prop {
-        Prop::Decimal(ref bd) => {
-            let (bint, scale) = bd.as_bigint_and_exponent();
-            if bint <= BigInt::from(DECIMAL_MAX) && scale <= 38 {
-                Ok(prop)
-            } else {
-                Err(InvalidBigDecimal(bd.clone()))
+pub struct SerdeArrowProp<'a>(pub &'a Prop);
+#[derive(Clone, Copy, Debug)]
+pub struct SerdeArrowList<'a>(pub &'a PropArray);
+
+#[derive(Clone, Copy, Debug)]
+pub struct SerdeArrowArray<'a>(pub &'a ArrayRef);
+#[derive(Clone, Copy)]
+pub struct SerdeArrowMap<'a>(pub &'a HashMap<ArcStr, Prop, FxBuildHasher>);
+
+#[derive(Clone, Copy, Serialize)]
+pub struct SerdeRow<P: Serialize> {
+    value: Option<P>,
+}
+
+impl<'a> Serialize for SerdeArrowList<'a> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match &self.0 {
+            PropArray::Vec(list) => {
+                let mut state = serializer.serialize_seq(Some(self.0.len()))?;
+                for prop in list.iter() {
+                    state.serialize_element(&SerdeArrowProp(prop))?;
+                }
+                state.end()
             }
+            PropArray::Array(array) => SerdeArrowArray(array).serialize(serializer),
         }
-        _ => Ok(prop),
     }
 }
 
-// auxiliary function to help with numerical conversion
-fn float_to_int<T>(val: f64) -> Result<T, String>
-where
-    T: FromPrimitive + Bounded + ToPrimitive,
-{
-    if val.is_nan() {
-        return Err("Cannot convert NaN to integer".into());
+impl<'a> Serialize for SerdeArrowMap<'a> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut state = serializer.serialize_map(Some(self.0.len()))?;
+        for (k, v) in self.0.iter() {
+            state.serialize_entry(k, &SerdeArrowProp(v))?;
+        }
+        state.end()
     }
+}
 
-    if val.is_infinite() {
-        return Err("Cannot convert infinite value to integer".into());
+impl<'a> Serialize for SerdeArrowProp<'a> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self.0 {
+            Prop::I32(i) => serializer.serialize_i32(*i),
+            Prop::I64(i) => serializer.serialize_i64(*i),
+            Prop::F32(f) => serializer.serialize_f32(*f),
+            Prop::F64(f) => serializer.serialize_f64(*f),
+            Prop::U8(u) => serializer.serialize_u8(*u),
+            Prop::U16(u) => serializer.serialize_u16(*u),
+            Prop::U32(u) => serializer.serialize_u32(*u),
+            Prop::U64(u) => serializer.serialize_u64(*u),
+            Prop::Str(s) => serializer.serialize_str(s),
+            Prop::Bool(b) => serializer.serialize_bool(*b),
+            Prop::DTime(dt) => serializer.serialize_i64(dt.timestamp_millis()),
+            Prop::NDTime(dt) => serializer.serialize_i64(dt.and_utc().timestamp_millis()),
+            Prop::List(l) => SerdeArrowList(l).serialize(serializer),
+            Prop::Map(m) => SerdeArrowMap(m).serialize(serializer),
+            Prop::Decimal(dec) => serializer.serialize_str(&dec.to_string()),
+        }
     }
-
-    // Try to convert using num_traits
-    T::from_f64(val).ok_or_else(|| format!("Value is out of bounds for target type: {}", val))
 }
 
-impl Prop {
-    // auxiliary function to help with numerical conversion
-    fn try_into_int<T>(self) -> Result<T, Error>
+impl<'a> Serialize for SerdeArrowArray<'a> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
-        T: FromPrimitive + Bounded,
+        S: Serializer,
     {
-        match self {
-            Prop::U8(v) => T::from_u8(v).ok_or(Error),
-            Prop::U16(v) => T::from_u16(v).ok_or(Error),
-            Prop::I32(v) => T::from_i32(v).ok_or(Error),
-            Prop::I64(v) => T::from_i64(v).ok_or(Error),
-            Prop::U32(v) => T::from_u32(v).ok_or(Error),
-            Prop::U64(v) => T::from_u64(v).ok_or(Error),
-            Prop::F32(v) => {
-                let as_f64 = v as f64;
-                float_to_int::<i64>(as_f64)
-                    .map_err(|_| Error)
-                    .and_then(|i| T::from_i64(i).ok_or(Error))
+        let dtype = self.0.data_type();
+        let len = self.0.len();
+        let mut state = serializer.serialize_seq(Some(len))?;
+        match dtype {
+            DataType::Boolean => {
+                for v in self.0.as_boolean().iter() {
+                    state.serialize_element(&v)?;
+                }
+            }
+            DataType::Int32 => {
+                for v in self.0.as_primitive::<Int32Type>().iter() {
+                    state.serialize_element(&v)?;
+                }
+            }
+            DataType::Int64 => {
+                for v in self.0.as_primitive::<Int64Type>().iter() {
+                    state.serialize_element(&v)?;
+                }
             }
-            Prop::F64(v) => float_to_int::<i64>(v)
-                .map_err(|_| Error)
-                .and_then(|i| T::from_i64(i).ok_or(Error)),
-            _ => Err(Error),
+            DataType::UInt8 => {
+                for v in self.0.as_primitive::<UInt8Type>().iter() {
+                    state.serialize_element(&v)?;
+                }
+            }
+            DataType::UInt16 => {
+                for v in self.0.as_primitive::<UInt16Type>().iter() {
+                    state.serialize_element(&v)?;
+                }
+            }
+            DataType::UInt32 => {
+                for v in self.0.as_primitive::<UInt32Type>().iter() {
+                    state.serialize_element(&v)?;
+                }
+            }
+            DataType::UInt64 => {
+                for v in self.0.as_primitive::<UInt64Type>().iter() {
+                    state.serialize_element(&v)?;
+                }
+            }
+            DataType::Float32 => {
+                for v in self.0.as_primitive::<Float32Type>().iter() {
+                    state.serialize_element(&v)?;
+                }
+            }
+            DataType::Float64 => {
+                for v in self.0.as_primitive::<Float64Type>().iter() {
+                    state.serialize_element(&v)?;
+                }
+            }
+            DataType::Timestamp(unit, _) => match unit {
+                TimeUnit::Second => {
+                    for v in self.0.as_primitive::<TimestampSecondType>().iter() {
+                        state.serialize_element(&v)?;
+                    }
+                }
+                TimeUnit::Millisecond => {
+                    for v in self.0.as_primitive::<TimestampMillisecondType>().iter() {
+                        state.serialize_element(&v)?;
+                    }
+                }
+                TimeUnit::Microsecond => {
+                    for v in self.0.as_primitive::<TimestampMicrosecondType>().iter() {
+                        state.serialize_element(&v)?;
+                    }
+                }
+                TimeUnit::Nanosecond => {
+                    for v in self.0.as_primitive::<TimestampNanosecondType>().iter() {
+                        state.serialize_element(&v)?;
+                    }
+                }
+            },
+            DataType::Date32 => {
+                for v in self.0.as_primitive::<Date32Type>().iter() {
+                    state.serialize_element(&v)?;
+                }
+            }
+            DataType::Date64 => {
+                for v in self.0.as_primitive::<Date64Type>().iter() {
+                    state.serialize_element(&v)?;
+                }
+            }
+            DataType::Utf8 => {
+                for v in self.0.as_string::<i32>().iter() {
+                    state.serialize_element(&v)?;
+                }
+            }
+            DataType::LargeUtf8 => {
+                for v in self.0.as_string::<i64>().iter() {
+                    state.serialize_element(&v)?;
+                }
+            }
+            DataType::Utf8View => {
+                for v in self.0.as_string_view().iter() {
+                    state.serialize_element(&v)?;
+                }
+            }
+            DataType::Decimal128(precision, scale) => {
+                for v in self.0.as_primitive::<Decimal128Type>().iter() {
+                    let element = v.map(|v| Decimal128Type::format_decimal(v, *precision, *scale));
+                    state.serialize_element(&element)?
+                    // i128 not supported by serde_arrow!
+                }
+            }
+            DataType::Struct(_) => {
+                let struct_array = self.0.as_struct();
+                match struct_array.nulls() {
+                    None => {
+                        for i in 0..struct_array.len() {
+                            state.serialize_element(&ArrowRow::new(struct_array, i))?;
+                        }
+                    }
+                    Some(nulls) => {
+                        for (i, is_valid) in nulls.iter().enumerate() {
+                            state.serialize_element(
+                                &is_valid.then_some(ArrowRow::new(struct_array, i)),
+                            )?;
+                        }
+                    }
+                }
+            }
+            DataType::List(_) => {
+                let list = self.0.as_list::<i32>();
+                for array in list.iter() {
+                    state.serialize_element(&array.as_ref().map(SerdeArrowArray))?;
+                }
+            }
+            DataType::LargeList(_) => {
+                let list = self.0.as_list::<i64>();
+                for array in list.iter() {
+                    state.serialize_element(&array.as_ref().map(SerdeArrowArray))?;
+                }
+            }
+            DataType::Null => {
+                for _ in 0..self.0.len() {
+                    state.serialize_element(&None::<()>)?;
+                }
+            }
+            dtype => Err(Error::custom(format!("unsuported data type {dtype:?}")))?,
         }
+        state.end()
     }
+}
 
-    // auxiliary function to help with numerical conversion
-    fn into_f64(self) -> Result<f64, Error> {
-        let result = match self {
-            Prop::U8(v) => v.to_f64(),
-            Prop::U16(v) => v.to_f64(),
-            Prop::I32(v) => v.to_f64(),
-            Prop::I64(v) => v.to_f64(),
-            Prop::U32(v) => v.to_f64(),
-            Prop::U64(v) => v.to_f64(),
-            Prop::F32(v) => v.to_f64(),
-            Prop::F64(v) => Some(v),
-            _ => None,
-        };
-        result.ok_or(Error)
+pub fn validate_bd(bd: &BigDecimal) -> Result<(), InvalidBigDecimal> {
+    let (bint, scale) = bd.as_bigint_and_exponent();
+    if bint <= BigInt::from(DECIMAL_MAX) && scale <= 38 {
+        Ok(())
+    } else {
+        Err(InvalidBigDecimal(bd.clone()))
     }
+}
 
+impl Prop {
     // auxiliary function to help with numerical conversion
-    fn try_into_f32(self) -> Result<Prop, Error> {
-        let as_f32 = match self {
-            Prop::U8(v) => v.to_f32(),
-            Prop::U16(v) => v.to_f32(),
-            Prop::I32(v) => v.to_f32(),
-            Prop::I64(v) => v.to_f32(),
-            Prop::U32(v) => v.to_f32(),
-            Prop::U64(v) => v.to_f32(),
-            Prop::F32(v) => Some(v),
-            Prop::F64(v) => {
-                // Check if f64 value fits in f32 range
-                if v.is_finite()
-                    && v.abs() <= f32::MAX as f64
-                    && (v == 0.0 || v.abs() >= f32::MIN_POSITIVE as f64)
-                {
-                    Some(v as f32)
-                } else if v.is_nan() || v.is_infinite() {
-                    Some(v as f32) // Preserve NaN and infinity
-                } else {
-                    None
-                }
-            }
+    pub fn cast_num<T>(self) -> Option<T>
+    where
+        T: FromPrimitive + Bounded,
+    {
+        match self {
+            Prop::U8(v) => T::from_u8(v),
+            Prop::U16(v) => T::from_u16(v),
+            Prop::I32(v) => T::from_i32(v),
+            Prop::I64(v) => T::from_i64(v),
+            Prop::U32(v) => T::from_u32(v),
+            Prop::U64(v) => T::from_u64(v),
+            Prop::F32(v) => T::from_f32(v),
+            Prop::F64(v) => T::from_f64(v),
             _ => None,
-        };
-        as_f32.map(Prop::F32).ok_or(Error)
+        }
     }
 
-    // convert prop into another prop type (primarily for numerical conversions)
-    pub fn try_cast(self, prop_type: PropType) -> Result<Prop, Error> {
+    /// convert prop into another prop type (primarily for numerical conversions)
+    pub fn try_cast(self, prop_type: PropType) -> Option<Prop> {
         // Early return if casting to the same type
         if self.dtype() == prop_type {
-            return Ok(self);
+            return Some(self);
         }
 
         match self {
             Prop::Str(v) => match prop_type {
-                PropType::Str => Ok(Prop::Str(v)),
-                PropType::U8 => v.parse::<u8>().map(Prop::U8).map_err(|_| Error),
-                PropType::U16 => v.parse::<u16>().map(Prop::U16).map_err(|_| Error),
-                PropType::I32 => v.parse::<i32>().map(Prop::I32).map_err(|_| Error),
-                PropType::I64 => v.parse::<i64>().map(Prop::I64).map_err(|_| Error),
-                PropType::U32 => v.parse::<u32>().map(Prop::U32).map_err(|_| Error),
-                PropType::U64 => v.parse::<u64>().map(Prop::U64).map_err(|_| Error),
-                PropType::F32 => v.parse::<f32>().map(Prop::F32).map_err(|_| Error),
-                PropType::F64 => v.parse::<f64>().map(Prop::F64).map_err(|_| Error),
-                PropType::Bool => v.parse::<bool>().map(Prop::Bool).map_err(|_| Error),
-                PropType::NDTime => v
-                    .parse::<NaiveDateTime>()
-                    .map(Prop::NDTime)
-                    .map_err(|_| Error),
-                PropType::DTime => v
-                    .parse::<DateTime<Utc>>()
-                    .map(Prop::DTime)
-                    .map_err(|_| Error),
+                PropType::Str => Some(Prop::Str(v)),
+                PropType::U8 => v.parse::<u8>().map(Prop::U8).ok(),
+                PropType::U16 => v.parse::<u16>().map(Prop::U16).ok(),
+                PropType::I32 => v.parse::<i32>().map(Prop::I32).ok(),
+                PropType::I64 => v.parse::<i64>().map(Prop::I64).ok(),
+                PropType::U32 => v.parse::<u32>().map(Prop::U32).ok(),
+                PropType::U64 => v.parse::<u64>().map(Prop::U64).ok(),
+                PropType::F32 => v.parse::<f32>().map(Prop::F32).ok(),
+                PropType::F64 => v.parse::<f64>().map(Prop::F64).ok(),
+                PropType::Bool => v.parse::<bool>().map(Prop::Bool).ok(),
+                PropType::NDTime => v.parse::<NaiveDateTime>().map(Prop::NDTime).ok(),
+                PropType::DTime => v.parse::<DateTime<Utc>>().map(Prop::DTime).ok(),
                 PropType::Decimal { scale } => v
                     .parse::<BigDecimal>()
                     .map(|v| Prop::Decimal(v.with_scale(scale)))
-                    .map_err(|_| Error),
-                _ => Err(Error),
+                    .ok(),
+                _ => None,
             },
             Prop::Bool(v) => match prop_type {
-                PropType::Str => Ok(Prop::Str(v.to_string().into())),
-                PropType::U8 => Ok(Prop::U8(if v { 1 } else { 0 })),
-                PropType::U16 => Ok(Prop::U16(if v { 1 } else { 0 })),
-                PropType::I32 => Ok(Prop::I32(if v { 1 } else { 0 })),
-                PropType::I64 => Ok(Prop::I64(if v { 1 } else { 0 })),
-                PropType::U32 => Ok(Prop::U32(if v { 1 } else { 0 })),
-                PropType::U64 => Ok(Prop::U64(if v { 1 } else { 0 })),
-                PropType::F32 => Ok(Prop::F32(if v { 1.0 } else { 0.0 })),
-                PropType::F64 => Ok(Prop::F64(if v { 1.0 } else { 0.0 })),
+                PropType::Str => Some(Prop::Str(v.to_string().into())),
+                PropType::U8 => Some(Prop::U8(v as _)),
+                PropType::U16 => Some(Prop::U16(v as _)),
+                PropType::I32 => Some(Prop::I32(v as _)),
+                PropType::I64 => Some(Prop::I64(v as _)),
+                PropType::U32 => Some(Prop::U32(v as _)),
+                PropType::U64 => Some(Prop::U64(v as _)),
+                PropType::F32 => Some(Prop::F32(if v { 1.0 } else { 0.0 })),
+                PropType::F64 => Some(Prop::F64(if v { 1.0 } else { 0.0 })),
                 PropType::Bool => unreachable!("Same type case handled above"),
                 PropType::Decimal { scale } => {
                     let val = if v {
@@ -360,87 +554,85 @@ impl Prop {
                     } else {
                         BigDecimal::from(0)
                     };
-                    Ok(Prop::Decimal(val.with_scale(scale)))
+                    Some(Prop::Decimal(val.with_scale(scale)))
                 }
-                _ => Err(Error),
+                _ => None,
             },
-            Prop::List(_v) => Err(Error),
-            Prop::Map(_v) => Err(Error),
+            Prop::List(_v) => None,
+            Prop::Map(_v) => None,
             Prop::NDTime(v) => match prop_type {
-                PropType::Str => Ok(Prop::Str(v.to_string().into())),
-                PropType::I64 => Ok(Prop::I64(v.and_utc().timestamp())),
+                PropType::Str => Some(Prop::Str(v.to_string().into())),
+                PropType::I64 => Some(Prop::I64(v.and_utc().timestamp())),
                 PropType::U64 => {
                     let ts = v.and_utc().timestamp();
                     if ts >= 0 {
-                        Ok(Prop::U64(ts as u64))
+                        Some(Prop::U64(ts as u64))
                     } else {
-                        Err(Error)
+                        None
                     }
                 }
-                PropType::DTime => Ok(Prop::DTime(v.and_utc())),
+                PropType::DTime => Some(Prop::DTime(v.and_utc())),
                 PropType::NDTime => unreachable!("Same type case handled above"),
-                _ => Err(Error),
+                _ => None,
             },
             Prop::DTime(v) => match prop_type {
-                PropType::Str => Ok(Prop::Str(v.to_rfc3339().into())),
-                PropType::I64 => Ok(Prop::I64(v.timestamp())),
+                PropType::Str => Some(Prop::Str(v.to_rfc3339().into())),
+                PropType::I64 => Some(Prop::I64(v.timestamp())),
                 PropType::U64 => {
                     let ts = v.timestamp();
                     if ts >= 0 {
-                        Ok(Prop::U64(ts as u64))
+                        Some(Prop::U64(ts as u64))
                     } else {
-                        Err(Error)
+                        None
                     }
                 }
-                PropType::NDTime => Ok(Prop::NDTime(v.naive_utc())),
+                PropType::NDTime => Some(Prop::NDTime(v.naive_utc())),
                 PropType::DTime => unreachable!("Same type case handled above"),
-                _ => Err(Error),
+                _ => None,
             },
-            #[cfg(feature = "arrow")]
-            Prop::Array(_v) => Err(Error),
             Prop::Decimal(v) => match prop_type {
-                PropType::Str => Ok(Prop::Str(v.to_string().into())),
+                PropType::Str => Some(Prop::Str(v.to_string().into())),
                 PropType::U8 => {
-                    let as_i64 = v.to_i64().ok_or(Error)?;
-                    u8::from_i64(as_i64).ok_or(Error).map(Prop::U8)
+                    let as_i64 = v.to_i64()?;
+                    u8::from_i64(as_i64).map(Prop::U8)
                 }
                 PropType::U16 => {
-                    let as_i64 = v.to_i64().ok_or(Error)?;
-                    u16::from_i64(as_i64).ok_or(Error).map(Prop::U16)
+                    let as_i64 = v.to_i64()?;
+                    u16::from_i64(as_i64).map(Prop::U16)
                 }
                 PropType::I32 => {
-                    let as_i64 = v.to_i64().ok_or(Error)?;
-                    i32::from_i64(as_i64).ok_or(Error).map(Prop::I32)
+                    let as_i64 = v.to_i64()?;
+                    i32::from_i64(as_i64).map(Prop::I32)
                 }
-                PropType::I64 => v.to_i64().ok_or(Error).map(Prop::I64),
+                PropType::I64 => v.to_i64().map(Prop::I64),
                 PropType::U32 => {
-                    let as_i64 = v.to_i64().ok_or(Error)?;
-                    u32::from_i64(as_i64).ok_or(Error).map(Prop::U32)
+                    let as_i64 = v.to_i64()?;
+                    u32::from_i64(as_i64).map(Prop::U32)
                 }
                 PropType::U64 => {
-                    let as_i64 = v.to_i64().ok_or(Error)?;
-                    u64::from_i64(as_i64).ok_or(Error).map(Prop::U64)
+                    let as_i64 = v.to_i64()?;
+                    u64::from_i64(as_i64).map(Prop::U64)
                 }
-                PropType::F32 => v.to_f32().ok_or(Error).map(Prop::F32),
-                PropType::F64 => v.to_f64().ok_or(Error).map(Prop::F64),
+                PropType::F32 => v.to_f32().map(Prop::F32),
+                PropType::F64 => v.to_f64().map(Prop::F64),
                 PropType::Bool => {
-                    let as_i64 = v.to_i64().ok_or(Error)?;
-                    Ok(Prop::Bool(as_i64 != 0))
+                    let as_i64 = v.to_i64()?;
+                    Some(Prop::Bool(as_i64 != 0))
                 }
-                PropType::Decimal { scale } => Ok(Prop::Decimal(v.with_scale(scale))),
-                _ => Err(Error),
+                PropType::Decimal { scale } => Some(Prop::Decimal(v.with_scale(scale))),
+                _ => None,
             },
             _ => match prop_type {
                 // Numeric conversions using num_traits
-                PropType::U8 => self.try_into_int::<u8>().map(Prop::U8),
-                PropType::U16 => self.try_into_int::<u16>().map(Prop::U16),
-                PropType::I32 => self.try_into_int::<i32>().map(Prop::I32),
-                PropType::I64 => self.try_into_int::<i64>().map(Prop::I64),
-                PropType::U32 => self.try_into_int::<u32>().map(Prop::U32),
-                PropType::U64 => self.try_into_int::<u64>().map(Prop::U64),
-                PropType::F32 => self.try_into_f32(),
-                PropType::F64 => self.into_f64().map(Prop::F64),
-                _ => Err(Error),
+                PropType::U8 => self.cast_num::<u8>().map(Prop::U8),
+                PropType::U16 => self.cast_num::<u16>().map(Prop::U16),
+                PropType::I32 => self.cast_num::<i32>().map(Prop::I32),
+                PropType::I64 => self.cast_num::<i64>().map(Prop::I64),
+                PropType::U32 => self.cast_num::<u32>().map(Prop::U32),
+                PropType::U64 => self.cast_num::<u64>().map(Prop::U64),
+                PropType::F32 => self.cast_num::<f32>().map(Prop::F32),
+                PropType::F64 => self.cast_num::<f64>().map(Prop::F64),
+                _ => None,
             },
         }
     }
@@ -478,8 +670,8 @@ impl Prop {
     }
 
     pub fn try_from_bd(bd: BigDecimal) -> Result<Prop, InvalidBigDecimal> {
-        let prop = Prop::Decimal(bd);
-        validate_prop(prop)
+        validate_bd(&bd)?;
+        Ok(Prop::Decimal(bd))
     }
 
     pub fn map(vals: impl IntoIterator<Item = (impl Into<ArcStr>, impl Into<Prop>)>) -> Self {
@@ -490,6 +682,13 @@ impl Prop {
         Prop::Map(h_map.into())
     }
 
+    pub fn as_map(&self) -> Option<SerdeArrowMap<'_>> {
+        match self {
+            Prop::Map(map) => Some(SerdeArrowMap(map)),
+            _ => None,
+        }
+    }
+
     pub fn dtype(&self) -> PropType {
         match self {
             Prop::Str(_) => PropType::Str,
@@ -502,26 +701,9 @@ impl Prop {
             Prop::F32(_) => PropType::F32,
             Prop::F64(_) => PropType::F64,
             Prop::Bool(_) => PropType::Bool,
-            Prop::List(list) => {
-                let list_type = list
-                    .iter()
-                    .map(|p| Ok(p.dtype()))
-                    .reduce(|a, b| unify_types(&a?, &b?, &mut false))
-                    .transpose()
-                    .map(|e| e.unwrap_or(PropType::Empty))
-                    .unwrap_or_else(|e| panic!("Cannot unify types for list {:?}: {e:?}", list));
-                PropType::List(Box::new(list_type))
-            }
+            Prop::List(list) => PropType::List(Box::new(list.dtype())),
             Prop::Map(map) => PropType::map(map.iter().map(|(k, v)| (k, v.dtype()))),
             Prop::NDTime(_) => PropType::NDTime,
-            #[cfg(feature = "arrow")]
-            Prop::Array(arr) => {
-                let arrow_dtype = arr
-                    .as_array_ref()
-                    .expect("Should not call dtype on empty PropArray")
-                    .data_type();
-                PropType::Array(Box::new(prop_type_from_arrow_dtype(arrow_dtype)))
-            }
             Prop::DTime(_) => PropType::DTime,
             Prop::Decimal(d) => PropType::Decimal {
                 scale: d.as_bigint_and_scale().1,
@@ -533,6 +715,12 @@ impl Prop {
         Prop::Str(s.into())
     }
 
+    pub fn list<P: Into<Prop>, I: IntoIterator<Item = P>>(vals: I) -> Prop {
+        Prop::List(PropArray::Vec(
+            vals.into_iter().map_into().collect::<Vec<_>>().into(),
+        ))
+    }
+
     pub fn add(self, other: Prop) -> Option<Prop> {
         match (self, other) {
             (Prop::U8(a), Prop::U8(b)) => Some(Prop::U8(a + b)),
@@ -583,6 +771,44 @@ impl Prop {
     }
 }
 
+pub fn list_array_from_props<P: Serialize + fmt::Debug + Clone>(
+    dt: &DataType,
+    props: impl IntoIterator<Item = Option<P>>,
+) -> Result<LargeListArray, serde_arrow::Error> {
+    use arrow_schema::{Field, Fields};
+    use serde_arrow::ArrayBuilder;
+
+    let fields: Fields = vec![Field::new("value", dt.clone(), true)].into();
+
+    let mut builder = ArrayBuilder::from_arrow(&fields)?;
+
+    for value in props {
+        builder.push(SerdeRow { value })?;
+    }
+
+    let arrays = builder.to_arrow()?;
+
+    Ok(arrays.first().unwrap().as_list::<i64>().clone())
+}
+
+pub fn struct_array_from_props<P: Serialize>(
+    dt: &DataType,
+    props: impl IntoIterator<Item = Option<P>>,
+) -> Result<StructArray, serde_arrow::Error> {
+    use serde_arrow::ArrayBuilder;
+
+    let fields = [FieldRef::new(Field::new("value", dt.clone(), true))];
+
+    let mut builder = ArrayBuilder::from_arrow(&fields)?;
+
+    for p in props {
+        builder.push(SerdeRow { value: p })?
+    }
+
+    let arrays = builder.to_arrow()?;
+    Ok(arrays.first().unwrap().as_struct().clone())
+}
+
 impl Display for Prop {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         match self {
@@ -598,8 +824,6 @@ impl Display for Prop {
             Prop::Bool(value) => write!(f, "{}", value),
             Prop::DTime(value) => write!(f, "{}", value),
             Prop::NDTime(value) => write!(f, "{}", value),
-            #[cfg(feature = "arrow")]
-            Prop::Array(value) => write!(f, "{:?}", value),
             Prop::List(value) => {
                 write!(
                     f,
@@ -643,111 +867,15 @@ impl Display for Prop {
     }
 }
 
-impl From<ArcStr> for Prop {
-    fn from(value: ArcStr) -> Self {
-        Prop::Str(value)
-    }
-}
-
-impl From<&ArcStr> for Prop {
-    fn from(value: &ArcStr) -> Self {
-        Prop::Str(value.clone())
-    }
-}
-
-impl From<String> for Prop {
-    fn from(value: String) -> Self {
-        Prop::Str(value.into())
-    }
-}
-
-impl From<&String> for Prop {
-    fn from(s: &String) -> Self {
-        Prop::Str(s.as_str().into())
-    }
-}
-
-impl From<Arc<str>> for Prop {
-    fn from(s: Arc<str>) -> Self {
-        Prop::Str(s.into())
-    }
-}
-
-impl From<&Arc<str>> for Prop {
-    fn from(value: &Arc<str>) -> Self {
-        Prop::Str(value.clone().into())
-    }
-}
-
 impl From<&str> for Prop {
     fn from(s: &str) -> Self {
-        Prop::Str(s.to_owned().into())
-    }
-}
-
-impl From<i32> for Prop {
-    fn from(i: i32) -> Self {
-        Prop::I32(i)
-    }
-}
-
-impl From<u8> for Prop {
-    fn from(i: u8) -> Self {
-        Prop::U8(i)
-    }
-}
-
-impl From<u16> for Prop {
-    fn from(i: u16) -> Self {
-        Prop::U16(i)
-    }
-}
-
-impl From<i64> for Prop {
-    fn from(i: i64) -> Self {
-        Prop::I64(i)
-    }
-}
-
-impl From<BigDecimal> for Prop {
-    fn from(d: BigDecimal) -> Self {
-        Prop::Decimal(d)
-    }
-}
-
-impl From<u32> for Prop {
-    fn from(u: u32) -> Self {
-        Prop::U32(u)
-    }
-}
-
-impl From<u64> for Prop {
-    fn from(u: u64) -> Self {
-        Prop::U64(u)
-    }
-}
-
-impl From<f32> for Prop {
-    fn from(f: f32) -> Self {
-        Prop::F32(f)
-    }
-}
-
-impl From<f64> for Prop {
-    fn from(f: f64) -> Self {
-        Prop::F64(f)
-    }
-}
-
-impl From<DateTime<Utc>> for Prop {
-    fn from(f: DateTime<Utc>) -> Self {
-        Prop::DTime(f)
+        Prop::Str(s.into())
     }
 }
 
-impl From<bool> for Prop {
-    fn from(b: bool) -> Self {
-        Prop::Bool(b)
+impl From<String> for Prop {
+    fn from(s: String) -> Self {
+        Prop::Str(s.into())
     }
 }
 
@@ -765,7 +893,7 @@ impl From<FxHashMap<ArcStr, Prop>> for Prop {
 
 impl From<Vec<Prop>> for Prop {
     fn from(value: Vec<Prop>) -> Self {
-        Prop::List(Arc::new(value))
+        Prop::List(value.into())
     }
 }
 
@@ -775,6 +903,12 @@ impl From<&Prop> for Prop {
     }
 }
 
+impl From<ArrayRef> for Prop {
+    fn from(value: ArrayRef) -> Self {
+        Prop::List(PropArray::from(value))
+    }
+}
+
 pub trait IntoPropMap {
     fn into_prop_map(self) -> Prop;
 }
@@ -795,7 +929,8 @@ pub trait IntoPropList {
 
 impl<I: IntoIterator<Item = K>, K: Into<Prop>> IntoPropList for I {
     fn into_prop_list(self) -> Prop {
-        Prop::List(Arc::new(self.into_iter().map(|v| v.into()).collect()))
+        let vec = self.into_iter().map(|v| v.into()).collect::<Vec<_>>();
+        Prop::List(vec.into())
     }
 }
 
diff --git a/raphtory-api/src/core/entities/properties/prop/prop_ref_enum.rs b/raphtory-api/src/core/entities/properties/prop/prop_ref_enum.rs
new file mode 100644
index 0000000000..549f81b471
--- /dev/null
+++ b/raphtory-api/src/core/entities/properties/prop/prop_ref_enum.rs
@@ -0,0 +1,239 @@
+use crate::core::{
+    entities::properties::prop::{
+        prop_col::{MapCol, PropCol},
+        validate_bd, ArrowRow, InvalidBigDecimal, Prop, PropArray, PropUnwrap, SerdeArrowList,
+        SerdeArrowMap,
+    },
+    storage::arc_str::ArcStr,
+};
+use bigdecimal::BigDecimal;
+use chrono::{DateTime, NaiveDateTime, Utc};
+use num_traits::ToPrimitive;
+use rustc_hash::FxHashMap;
+use serde::Serialize;
+use std::{borrow::Cow, sync::Arc};
+
+#[derive(Debug, Clone)]
+pub enum PropRef<'a> {
+    Str(&'a str),
+    Num(PropNum),
+    Bool(bool),
+    List(Cow<'a, PropArray>),
+    Map(PropMapRef<'a>),
+    NDTime(NaiveDateTime),
+    DTime(DateTime<Utc>),
+    Decimal { num: i128, scale: i8 },
+}
+
+impl PropRef<'_> {
+    pub fn as_map_ref(&self) -> Option<PropMapRef<'_>> {
+        if let PropRef::Map(m) = self {
+            Some(*m)
+        } else {
+            None
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub enum PropMapRef<'a> {
+    Mem(&'a Arc<FxHashMap<ArcStr, Prop>>),
+    PropCol { map: &'a MapCol, i: usize },
+    Arrow(ArrowRow<'a>),
+}
+
+impl<'a> PropMapRef<'a> {
+    pub fn into_prop(self) -> Option<Prop> {
+        match self {
+            PropMapRef::Mem(map) => Some(Prop::Map(map.clone())),
+            PropMapRef::PropCol { map, i } => map.get(i),
+            PropMapRef::Arrow(row) => row.into_prop(),
+        }
+    }
+
+    pub fn as_map(&self) -> Option<&'a Arc<FxHashMap<ArcStr, Prop>>> {
+        if let PropMapRef::Mem(m) = self {
+            Some(*m)
+        } else {
+            None
+        }
+    }
+
+    pub fn as_mem(&self) -> Arc<FxHashMap<ArcStr, Prop>> {
+        match self {
+            PropMapRef::Mem(m) => (*m).clone(),
+            PropMapRef::PropCol { map, i } => map.get(*i).unwrap_map(),
+            PropMapRef::Arrow(row) => row.into_prop().unwrap_map(),
+        }
+    }
+}
+
+impl<T: Into<PropNum>> From<T> for PropRef<'static> {
+    fn from(n: T) -> Self {
+        PropRef::Num(n.into())
+    }
+}
+
+impl<'a> From<bool> for PropRef<'a> {
+    fn from(b: bool) -> Self {
+        PropRef::Bool(b)
+    }
+}
+
+impl<'a> From<&'a str> for PropRef<'a> {
+    fn from(s: &'a str) -> Self {
+        PropRef::Str(s)
+    }
+}
+
+impl From<NaiveDateTime> for PropRef<'_> {
+    fn from(dt: NaiveDateTime) -> Self {
+        PropRef::NDTime(dt)
+    }
+}
+
+impl From<DateTime<Utc>> for PropRef<'_> {
+    fn from(dt: DateTime<Utc>) -> Self {
+        PropRef::DTime(dt)
+    }
+}
+
+impl<'a> From<&'a BigDecimal> for PropRef<'a> {
+    fn from(decimal: &'a BigDecimal) -> Self {
+        let (num, scale) = decimal.as_bigint_and_exponent();
+        let num = num.to_i128().unwrap_or_else(|| {
+            panic!(
+                "BigDecimal value {} is out of range for i128 representation",
+                decimal
+            )
+        });
+        PropRef::Decimal {
+            num,
+            scale: scale as i8,
+        }
+    }
+}
+
+impl<'a> From<ArrowRow<'a>> for PropRef<'a> {
+    fn from(row: ArrowRow<'a>) -> Self {
+        PropRef::Map(PropMapRef::Arrow(row))
+    }
+}
+
+impl<'a> From<&'a Arc<FxHashMap<ArcStr, Prop>>> for PropRef<'a> {
+    fn from(map: &'a Arc<FxHashMap<ArcStr, Prop>>) -> Self {
+        PropRef::Map(PropMapRef::Mem(map))
+    }
+}
+
+#[derive(Debug, PartialEq, Clone, Copy, derive_more::From)]
+pub enum PropNum {
+    U8(u8),
+    U16(u16),
+    I32(i32),
+    I64(i64),
+    U32(u32),
+    U64(u64),
+    F32(f32),
+    F64(f64),
+}
+
+/// A trait for types that can be cheaply viewed as a [`PropRef`].
+pub trait AsPropRef {
+    fn as_prop_ref(&self) -> PropRef<'_>;
+}
+
+impl<'a> AsPropRef for PropRef<'a> {
+    #[inline]
+    fn as_prop_ref(&self) -> PropRef<'_> {
+        self.clone()
+    }
+}
+
+impl AsPropRef for Prop {
+    fn as_prop_ref(&self) -> PropRef<'_> {
+        match self {
+            Prop::Str(s) => PropRef::Str(s),
+            Prop::U8(v) => PropRef::Num(PropNum::U8(*v)),
+            Prop::U16(v) => PropRef::Num(PropNum::U16(*v)),
+            Prop::I32(v) => PropRef::Num(PropNum::I32(*v)),
+            Prop::I64(v) => PropRef::Num(PropNum::I64(*v)),
+            Prop::U32(v) => PropRef::Num(PropNum::U32(*v)),
+            Prop::U64(v) => PropRef::Num(PropNum::U64(*v)),
+            Prop::F32(v) => PropRef::Num(PropNum::F32(*v)),
+            Prop::F64(v) => PropRef::Num(PropNum::F64(*v)),
+            Prop::Bool(b) => PropRef::Bool(*b),
+            Prop::List(lst) => PropRef::List(std::borrow::Cow::Borrowed(lst)),
+            Prop::Map(map) => PropRef::Map(PropMapRef::Mem(map)),
+            Prop::NDTime(dt) => PropRef::NDTime(*dt),
+            Prop::DTime(dt) => PropRef::DTime(*dt),
+            Prop::Decimal(bd) => PropRef::from(bd),
+        }
+    }
+}
+
+impl<'a> PropRef<'a> {
+    pub fn as_str(&self) -> Option<&'a str> {
+        if let PropRef::Str(s) = self {
+            Some(s)
+        } else {
+            None
+        }
+    }
+
+    pub fn try_from_bd(bd: BigDecimal) -> Result<Self, InvalidBigDecimal> {
+        validate_bd(&bd)?;
+        let (num, scale) = bd.as_bigint_and_exponent();
+        let num = num.to_i128().unwrap();
+        Ok(PropRef::Decimal {
+            num,
+            scale: scale as i8,
+        })
+    }
+}
+
+impl<'a> Serialize for PropMapRef<'a> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match self {
+            PropMapRef::Mem(map) => SerdeArrowMap(map).serialize(serializer),
+            PropMapRef::PropCol { map, i } => match map.get_ref(*i) {
+                Some(prop) => prop.serialize(serializer),
+                None => serializer.serialize_none(),
+            },
+            PropMapRef::Arrow(row) => row.serialize(serializer),
+        }
+    }
+}
+
+impl<'a> Serialize for PropRef<'a> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match self {
+            PropRef::Str(s) => serializer.serialize_str(s),
+            PropRef::Num(n) => match n {
+                PropNum::U8(v) => serializer.serialize_u8(*v),
+                PropNum::U16(v) => serializer.serialize_u16(*v),
+                PropNum::I32(v) => serializer.serialize_i32(*v),
+                PropNum::I64(v) => serializer.serialize_i64(*v),
+                PropNum::U32(v) => serializer.serialize_u32(*v),
+                PropNum::U64(v) => serializer.serialize_u64(*v),
+                PropNum::F32(v) => serializer.serialize_f32(*v),
+                PropNum::F64(v) => serializer.serialize_f64(*v),
+            },
+            PropRef::Bool(b) => serializer.serialize_bool(*b),
+            PropRef::List(lst) => SerdeArrowList(lst).serialize(serializer),
+            PropRef::Map(map_ref) => map_ref.serialize(serializer),
+            PropRef::NDTime(dt) => serializer.serialize_i64(dt.and_utc().timestamp_millis()),
+            PropRef::DTime(dt) => serializer.serialize_i64(dt.timestamp_millis()),
+            PropRef::Decimal { num, scale } => {
+                let decimal = BigDecimal::new((*num).into(), (*scale).into());
+                decimal.serialize(serializer)
+            }
+        }
+    }
+}
diff --git a/raphtory-api/src/core/entities/properties/prop/prop_type.rs b/raphtory-api/src/core/entities/properties/prop/prop_type.rs
index 84e7299883..1807084aa5 100644
--- a/raphtory-api/src/core/entities/properties/prop/prop_type.rs
+++ b/raphtory-api/src/core/entities/properties/prop/prop_type.rs
@@ -1,4 +1,3 @@
-#[cfg(any(feature = "arrow", feature = "storage", feature = "python"))]
 use arrow_schema::DataType;
 use serde::{Deserialize, Serialize};
 use std::{
@@ -40,7 +39,6 @@ pub enum PropType {
     Map(Arc<HashMap<String, PropType>>),
     NDTime,
     DTime,
-    Array(Box<PropType>),
     Decimal {
         scale: i64,
     },
@@ -71,7 +69,6 @@ impl Display for PropType {
             }
             PropType::NDTime => "NDTime",
             PropType::DTime => "DTime",
-            PropType::Array(p_type) => return write!(f, "Array<{}>", p_type),
             PropType::Decimal { scale } => return write!(f, "Decimal({})", scale),
         };
 
@@ -142,9 +139,27 @@ impl PropType {
         }
         None
     }
+
+    // This is the best guess for the size of one row of properties
+    pub fn est_size(&self) -> usize {
+        const CONTAINER_SIZE: usize = 64;
+        match self {
+            PropType::Str => CONTAINER_SIZE,
+            PropType::U8 | PropType::Bool => 1,
+            PropType::U16 => 2,
+            PropType::I32 | PropType::F32 | PropType::U32 => 4,
+            PropType::I64 | PropType::F64 | PropType::U64 => 8,
+            PropType::NDTime | PropType::DTime => 8,
+            PropType::List(p_type) => p_type.est_size() * CONTAINER_SIZE,
+            PropType::Map(p_map) => {
+                p_map.values().map(|v| v.est_size()).sum::<usize>() * CONTAINER_SIZE
+            }
+            PropType::Decimal { .. } => 16,
+            PropType::Empty => 0,
+        }
+    }
 }
 
-#[cfg(any(feature = "arrow", feature = "storage", feature = "python"))]
 pub fn data_type_as_prop_type(dt: &DataType) -> Result<PropType, InvalidPropertyTypeErr> {
     match dt {
         DataType::Boolean => Ok(PropType::Bool),
@@ -187,22 +202,18 @@ pub fn data_type_as_prop_type(dt: &DataType) -> Result<PropType, InvalidProperty
     }
 }
 
-#[cfg(any(feature = "arrow", feature = "storage", feature = "python"))]
 #[derive(thiserror::Error, Debug)]
 #[error("{0:?} not supported as property type")]
 pub struct InvalidPropertyTypeErr(pub DataType);
 
-#[cfg(any(feature = "arrow", feature = "storage"))]
-mod arrow {
-    use crate::core::entities::properties::prop::PropType;
-    use arrow_schema::DataType;
+pub mod arrow {
+    use crate::core::entities::properties::prop::{PropType, EMPTY_MAP_FIELD_NAME};
+    use arrow_schema::{DataType, TimeUnit};
 
     impl From<&DataType> for PropType {
         fn from(value: &DataType) -> Self {
             match value {
-                DataType::Utf8 => PropType::Str,
-                DataType::LargeUtf8 => PropType::Str,
-                DataType::Utf8View => PropType::Str,
+                DataType::Utf8View | DataType::LargeUtf8 | DataType::Utf8 => PropType::Str,
                 DataType::UInt8 => PropType::U8,
                 DataType::UInt16 => PropType::U16,
                 DataType::Int32 => PropType::I32,
@@ -215,8 +226,21 @@ mod arrow {
                     scale: *scale as i64,
                 },
                 DataType::Boolean => PropType::Bool,
-
-                _ => PropType::Empty,
+                DataType::Timestamp(TimeUnit::Millisecond, None) => PropType::NDTime,
+                DataType::Timestamp(TimeUnit::Millisecond, tz) if tz.as_deref() == Some("UTC") => {
+                    PropType::DTime
+                }
+                DataType::Struct(fields) => PropType::map(
+                    fields
+                        .iter()
+                        .filter(|field| field.name() != EMPTY_MAP_FIELD_NAME)
+                        .map(|f| (f.name().to_string(), PropType::from(f.data_type()))),
+                ),
+                DataType::List(field) | DataType::LargeList(field) => {
+                    PropType::List(Box::new(PropType::from(field.data_type())))
+                }
+                DataType::Null => PropType::Empty,
+                dtype => panic!("unsupported type {dtype:?}"),
             }
         }
     }
@@ -250,9 +274,6 @@ pub fn unify_types(l: &PropType, r: &PropType, unified: &mut bool) -> Result<Pro
         (PropType::List(l_type), PropType::List(r_type)) => {
             unify_types(l_type, r_type, unified).map(|t| PropType::List(Box::new(t)))
         }
-        (PropType::Array(l_type), PropType::Array(r_type)) => {
-            unify_types(l_type, r_type, unified).map(|t| PropType::Array(Box::new(t)))
-        }
         (PropType::Map(l_map), PropType::Map(r_map)) => {
             // maps need to be merged and only overlapping keys need to be unified
 
@@ -287,6 +308,64 @@ pub fn unify_types(l: &PropType, r: &PropType, unified: &mut bool) -> Result<Pro
     }
 }
 
+// fast check before we actually unify, 99% of the time this will be enough
+// there are 3 outcomes,
+// types are identical so no unification needed, None
+// types can be unified Some(true)
+// and types cannot be unified Some(false)
+pub fn check_for_unification(l: &PropType, r: &PropType) -> Option<bool> {
+    match (l, r) {
+        (PropType::Empty, _) => Some(true),
+        (_, PropType::Empty) => Some(true),
+        (PropType::Str, PropType::Str) => None,
+        (PropType::U8, PropType::U8) => None,
+        (PropType::U16, PropType::U16) => None,
+        (PropType::I32, PropType::I32) => None,
+        (PropType::I64, PropType::I64) => None,
+        (PropType::U32, PropType::U32) => None,
+        (PropType::U64, PropType::U64) => None,
+        (PropType::F32, PropType::F32) => None,
+        (PropType::F64, PropType::F64) => None,
+        (PropType::Bool, PropType::Bool) => None,
+        (PropType::NDTime, PropType::NDTime) => None,
+        (PropType::DTime, PropType::DTime) => None,
+        (PropType::List(l_type), PropType::List(r_type)) => check_for_unification(l_type, r_type),
+        (PropType::Map(l_map), PropType::Map(r_map)) => {
+            let keys_check = l_map
+                .keys()
+                .any(|k| !r_map.contains_key(k))
+                .then_some(true)
+                .or_else(|| r_map.keys().any(|k| !l_map.contains_key(k)).then_some(true));
+
+            // check for unification of the values
+            let inner_checks = l_map
+                .iter()
+                .filter_map(|(l_key, l_d_type)| {
+                    r_map
+                        .get(l_key)
+                        .and_then(|r_d_type| check_for_unification(r_d_type, l_d_type))
+                })
+                .chain(r_map.iter().filter_map(|(r_key, r_d_type)| {
+                    l_map
+                        .get(r_key)
+                        .and_then(|l_d_type| check_for_unification(r_d_type, l_d_type))
+                }));
+            for check in inner_checks {
+                if check {
+                    return Some(true);
+                }
+            }
+            keys_check
+        }
+        (PropType::Decimal { scale: l_scale }, PropType::Decimal { scale: r_scale })
+            if l_scale == r_scale =>
+        {
+            None
+        }
+        _ => Some(false),
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
@@ -397,15 +476,15 @@ mod test {
         );
         assert!(unify);
 
-        let l = PropType::Array(Box::new(PropType::map([("a".to_string(), PropType::U8)])));
-        let r = PropType::Array(Box::new(PropType::map([
+        let l = PropType::List(Box::new(PropType::map([("a".to_string(), PropType::U8)])));
+        let r = PropType::List(Box::new(PropType::map([
             ("a".to_string(), PropType::Empty),
             ("b".to_string(), PropType::Str),
         ])));
         let mut unify = false;
         assert_eq!(
             unify_types(&l, &r, &mut unify),
-            Ok(PropType::Array(Box::new(PropType::map([
+            Ok(PropType::List(Box::new(PropType::map([
                 ("a".to_string(), PropType::U8),
                 ("b".to_string(), PropType::Str)
             ]))))
diff --git a/raphtory-api/src/core/entities/properties/prop/prop_unwrap.rs b/raphtory-api/src/core/entities/properties/prop/prop_unwrap.rs
index f9e29bc1b5..133d12b3f7 100644
--- a/raphtory-api/src/core/entities/properties/prop/prop_unwrap.rs
+++ b/raphtory-api/src/core/entities/properties/prop/prop_unwrap.rs
@@ -1,4 +1,7 @@
-use crate::core::{entities::properties::prop::Prop, storage::arc_str::ArcStr};
+use crate::core::{
+    entities::properties::prop::{Prop, PropArray},
+    storage::arc_str::ArcStr,
+};
 use bigdecimal::BigDecimal;
 use chrono::NaiveDateTime;
 use rustc_hash::FxHashMap;
@@ -55,8 +58,8 @@ pub trait PropUnwrap: Sized {
         self.into_bool().unwrap()
     }
 
-    fn into_list(self) -> Option<Arc<Vec<Prop>>>;
-    fn unwrap_list(self) -> Arc<Vec<Prop>> {
+    fn into_list(self) -> Option<PropArray>;
+    fn unwrap_list(self) -> PropArray {
         self.into_list().unwrap()
     }
 
@@ -116,7 +119,7 @@ impl<P: PropUnwrap> PropUnwrap for Option<P> {
         self.and_then(|p| p.into_bool())
     }
 
-    fn into_list(self) -> Option<Arc<Vec<Prop>>> {
+    fn into_list(self) -> Option<PropArray> {
         self.and_then(|p| p.into_list())
     }
 
@@ -218,7 +221,7 @@ impl PropUnwrap for Prop {
         }
     }
 
-    fn into_list(self) -> Option<Arc<Vec<Prop>>> {
+    fn into_list(self) -> Option<PropArray> {
         if let Prop::List(v) = self {
             Some(v)
         } else {
diff --git a/raphtory-api/src/core/entities/properties/prop/serde.rs b/raphtory-api/src/core/entities/properties/prop/serde.rs
index 56b35b2679..fd33605a90 100644
--- a/raphtory-api/src/core/entities/properties/prop/serde.rs
+++ b/raphtory-api/src/core/entities/properties/prop/serde.rs
@@ -14,7 +14,7 @@ impl TryFrom<Value> for Prop {
                 .map(|num| num.into())
                 .or_else(|| value.as_f64().map(|num| num.into()))
                 .ok_or(format!("Number conversion error for: {}", value)),
-            Value::String(value) => Ok(value.into()),
+            Value::String(value) => Ok(value.as_str().into()),
             Value::Array(value) => value
                 .into_iter()
                 .map(|item| item.try_into())
@@ -49,7 +49,7 @@ impl From<Prop> for Value {
                 .map(Value::Number)
                 .unwrap_or(Value::Null),
             Prop::Bool(value) => Value::Bool(value),
-            Prop::List(values) => Value::Array(values.iter().cloned().map(Value::from).collect()),
+            Prop::List(values) => Value::Array(values.iter().map(Value::from).collect()),
             Prop::Map(map) => {
                 let json_map: serde_json::Map<String, Value> = map
                     .iter()
diff --git a/raphtory-api/src/core/entities/properties/prop/template.rs b/raphtory-api/src/core/entities/properties/prop/template.rs
index 21f55ed2e5..12209991e1 100644
--- a/raphtory-api/src/core/entities/properties/prop/template.rs
+++ b/raphtory-api/src/core/entities/properties/prop/template.rs
@@ -17,9 +17,7 @@ impl From<Prop> for Value {
             Prop::Str(value) => Value::from(value.0.to_owned()),
             Prop::DTime(value) => Value::from(value.timestamp_millis()),
             Prop::NDTime(value) => Value::from(value.and_utc().timestamp_millis()),
-            #[cfg(feature = "arrow")]
-            Prop::Array(value) => Value::from(value.to_vec_u8()),
-            Prop::List(value) => value.iter().cloned().collect(),
+            Prop::List(value) => value.iter().collect(),
             Prop::Map(value) => value
                 .iter()
                 .map(|(key, value)| (key.to_string(), value.clone()))
diff --git a/raphtory-api/src/core/entities/properties/tprop.rs b/raphtory-api/src/core/entities/properties/tprop.rs
index f5510f1885..bcf4c2e3c1 100644
--- a/raphtory-api/src/core/entities/properties/tprop.rs
+++ b/raphtory-api/src/core/entities/properties/tprop.rs
@@ -15,24 +15,46 @@ pub trait TPropOps<'a>: Clone + Send + Sync + Sized + 'a {
     }
 
     fn last_before(&self, t: EventTime) -> Option<(EventTime, Prop)> {
-        self.clone().iter_window(EventTime::MIN..t).next_back()
+        self.clone().iter_inner_rev(Some(EventTime::MIN..t)).next()
     }
 
-    fn iter(self) -> impl DoubleEndedIterator<Item = (EventTime, Prop)> + Send + Sync + 'a;
+    fn iter_inner(
+        self,
+        range: Option<Range<EventTime>>,
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'a;
 
-    fn iter_t(self) -> impl DoubleEndedIterator<Item = (i64, Prop)> + Send + Sync + 'a {
-        self.iter().map(|(t, v)| (t.t(), v))
+    fn iter_inner_rev(
+        self,
+        range: Option<Range<EventTime>>,
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'a;
+
+    fn iter(self) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'a {
+        self.iter_inner(None)
+    }
+
+    fn iter_rev(self) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'a {
+        self.iter_inner_rev(None)
     }
 
     fn iter_window(
         self,
         r: Range<EventTime>,
-    ) -> impl DoubleEndedIterator<Item = (EventTime, Prop)> + Send + Sync + 'a;
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'a {
+        self.iter_inner(Some(r))
+    }
 
-    fn iter_window_t(
+    fn iter_window_rev(
         self,
-        r: Range<i64>,
-    ) -> impl DoubleEndedIterator<Item = (i64, Prop)> + Send + Sync + 'a {
+        r: Range<EventTime>,
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'a {
+        self.iter_inner_rev(Some(r))
+    }
+
+    fn iter_t(self) -> impl Iterator<Item = (i64, Prop)> + Send + Sync + 'a {
+        self.iter().map(|(t, v)| (t.t(), v))
+    }
+
+    fn iter_window_t(self, r: Range<i64>) -> impl Iterator<Item = (i64, Prop)> + Send + Sync + 'a {
         self.iter_window(EventTime::range(r))
             .map(|(t, v)| (t.t(), v))
     }
@@ -40,7 +62,7 @@ pub trait TPropOps<'a>: Clone + Send + Sync + Sized + 'a {
     fn iter_window_te(
         self,
         r: Range<EventTime>,
-    ) -> impl DoubleEndedIterator<Item = (i64, Prop)> + Send + Sync + 'a {
+    ) -> impl Iterator<Item = (i64, Prop)> + Send + Sync + 'a {
         self.iter_window(r).map(|(t, v)| (t.t(), v))
     }
 
diff --git a/raphtory-api/src/core/storage/dict_mapper.rs b/raphtory-api/src/core/storage/dict_mapper.rs
index d8f37b0e5e..0cc0c6c57b 100644
--- a/raphtory-api/src/core/storage/dict_mapper.rs
+++ b/raphtory-api/src/core/storage/dict_mapper.rs
@@ -1,17 +1,23 @@
-use crate::core::storage::{arc_str::ArcStr, locked_vec::ArcReadLockedVec, FxDashMap};
-use dashmap::mapref::entry::Entry;
-use parking_lot::RwLock;
+use crate::core::{
+    entities::properties::meta::STATIC_GRAPH_LAYER,
+    storage::{arc_str::ArcStr, ArcRwLockReadGuard},
+};
+use parking_lot::{RwLock, RwLockReadGuard, RwLockWriteGuard};
+use rustc_hash::FxHashMap;
 use serde::{Deserialize, Serialize};
 use std::{
     borrow::{Borrow, BorrowMut},
+    collections::hash_map::Entry,
     hash::Hash,
+    ops::{Deref, DerefMut},
     sync::Arc,
 };
 
-#[derive(Serialize, Deserialize, Default, Debug)]
+#[derive(Serialize, Deserialize, Default, Debug, Clone)]
 pub struct DictMapper {
-    map: FxDashMap<ArcStr, usize>,
-    reverse_map: Arc<RwLock<Vec<ArcStr>>>, //FIXME: a boxcar vector would be a great fit if it was serializable...
+    map: Arc<RwLock<FxHashMap<ArcStr, usize>>>,
+    reverse_map: Arc<RwLock<Vec<ArcStr>>>,
+    num_private_fields: usize,
 }
 
 #[derive(Copy, Clone, Debug)]
@@ -31,6 +37,11 @@ where
 }
 
 impl<Index> MaybeNew<Index> {
+    #[inline]
+    pub fn is_new(&self) -> bool {
+        matches!(self, MaybeNew::New(_))
+    }
+
     #[inline]
     pub fn inner(self) -> Index {
         match self {
@@ -81,6 +92,13 @@ impl<Index> MaybeNew<Index> {
             MaybeNew::Existing(_) => None,
         }
     }
+
+    pub fn into_inner_with_status(self) -> (Index, bool) {
+        match self {
+            MaybeNew::New(inner) => (inner, true),
+            MaybeNew::Existing(inner) => (inner, false),
+        }
+    }
 }
 
 impl<Index> Borrow<Index> for MaybeNew<Index> {
@@ -97,33 +115,144 @@ impl<Index> BorrowMut<Index> for MaybeNew<Index> {
     }
 }
 
+pub struct LockedDictMapper<'a> {
+    map: RwLockReadGuard<'a, FxHashMap<ArcStr, usize>>,
+    reverse_map: RwLockReadGuard<'a, Vec<ArcStr>>,
+    num_private_fields: usize,
+}
+
+pub struct WriteLockedDictMapper<'a> {
+    map: RwLockWriteGuard<'a, FxHashMap<ArcStr, usize>>,
+    reverse_map: RwLockWriteGuard<'a, Vec<ArcStr>>,
+}
+
+impl LockedDictMapper<'_> {
+    pub fn get_id(&self, name: &str) -> Option<usize> {
+        self.map.get(name).copied()
+    }
+
+    pub fn map(&self) -> &FxHashMap<ArcStr, usize> {
+        &self.map
+    }
+
+    pub fn iter_ids(&self) -> impl Iterator<Item = (usize, &ArcStr)> + '_ {
+        self.reverse_map
+            .iter()
+            .enumerate()
+            .skip(self.num_private_fields)
+    }
+}
+
+impl WriteLockedDictMapper<'_> {
+    pub fn get_or_create_id<Q, T>(&mut self, name: &Q) -> MaybeNew<usize>
+    where
+        Q: Hash + Eq + ?Sized + ToOwned<Owned = T> + Borrow<str>,
+        T: Into<ArcStr>,
+    {
+        let name = name.to_owned().into();
+        let new_id = match self.map.entry(name.clone()) {
+            Entry::Occupied(entry) => MaybeNew::Existing(*entry.get()),
+            Entry::Vacant(entry) => {
+                let id = self.reverse_map.len();
+                self.reverse_map.push(name);
+                entry.insert(id);
+                MaybeNew::New(id)
+            }
+        };
+        new_id
+    }
+
+    pub fn set_id(&mut self, name: impl Into<ArcStr>, id: usize) {
+        let arc_name = name.into();
+        let map_entry = self.map.entry(arc_name.clone());
+        let keys = self.reverse_map.deref_mut();
+        if keys.len() <= id {
+            keys.resize(id + 1, Default::default())
+        }
+        keys[id] = arc_name;
+        map_entry.insert_entry(id);
+    }
+
+    pub fn map(&self) -> &FxHashMap<ArcStr, usize> {
+        &self.map
+    }
+}
+
 impl DictMapper {
+    fn read_lock_reverse_map(&self) -> RwLockReadGuard<'_, Vec<ArcStr>> {
+        self.reverse_map.read_recursive()
+    }
+
+    fn write_lock_reverse_map(&self) -> RwLockWriteGuard<'_, Vec<ArcStr>> {
+        self.reverse_map.write()
+    }
+
+    fn read_arc_lock_reverse_map(&self) -> ArcRwLockReadGuard<Vec<ArcStr>> {
+        self.reverse_map.read_arc_recursive()
+    }
+
+    pub fn new_layer_mapper() -> Self {
+        Self::new_with_private_fields([STATIC_GRAPH_LAYER])
+    }
+
+    pub fn new_with_private_fields(fields: impl IntoIterator<Item = impl Into<ArcStr>>) -> Self {
+        let fields: Vec<_> = fields.into_iter().map(|s| s.into()).collect();
+        let num_private_fields = fields.len();
+        DictMapper {
+            map: Arc::new(Default::default()),
+            reverse_map: Arc::new(RwLock::new(fields)),
+            num_private_fields,
+        }
+    }
     pub fn contains(&self, key: &str) -> bool {
-        self.map.contains_key(key)
+        self.map.read_recursive().contains_key(key)
     }
 
     pub fn deep_clone(&self) -> Self {
-        let reverse_map = self.reverse_map.read_recursive().clone();
+        let map = self.map.read_recursive().clone();
+        let reverse_map = self.read_lock_reverse_map().clone();
 
         Self {
-            map: self.map.clone(),
+            map: Arc::new(RwLock::new(map)),
             reverse_map: Arc::new(RwLock::new(reverse_map)),
+            num_private_fields: self.num_private_fields,
         }
     }
+
+    pub fn read(&self) -> LockedDictMapper<'_> {
+        LockedDictMapper {
+            map: self.map.read_recursive(),
+            reverse_map: self.read_lock_reverse_map(),
+            num_private_fields: self.num_private_fields,
+        }
+    }
+
+    pub fn write(&self) -> WriteLockedDictMapper<'_> {
+        WriteLockedDictMapper {
+            map: self.map.write(),
+            reverse_map: self.write_lock_reverse_map(),
+        }
+    }
+
     pub fn get_or_create_id<Q, T>(&self, name: &Q) -> MaybeNew<usize>
     where
         Q: Hash + Eq + ?Sized + ToOwned<Owned = T> + Borrow<str>,
         T: Into<ArcStr>,
     {
-        if let Some(existing_id) = self.map.get(name.borrow()) {
+        let map = self.map.read_recursive();
+
+        if let Some(existing_id) = map.get(name.borrow()) {
             return MaybeNew::Existing(*existing_id);
         }
+        drop(map);
+
+        let mut map = self.map.write();
 
         let name = name.to_owned().into();
-        let new_id = match self.map.entry(name.clone()) {
+        let new_id = match map.entry(name.clone()) {
             Entry::Occupied(entry) => MaybeNew::Existing(*entry.get()),
             Entry::Vacant(entry) => {
-                let mut reverse = self.reverse_map.write();
+                let mut reverse = self.write_lock_reverse_map();
                 let id = reverse.len();
                 reverse.push(name);
                 entry.insert(id);
@@ -134,57 +263,164 @@ impl DictMapper {
     }
 
     pub fn get_id(&self, name: &str) -> Option<usize> {
-        self.map.get(name).map(|id| *id)
+        self.map.read_recursive().get(name).copied()
     }
 
     /// Explicitly set the id for a key (useful for initialising the map in parallel)
     pub fn set_id(&self, name: impl Into<ArcStr>, id: usize) {
+        let mut map = self.map.write();
         let arc_name = name.into();
-        let map_entry = self.map.entry(arc_name.clone());
-        let mut keys = self.reverse_map.write();
+        let map_entry = map.entry(arc_name.clone());
+        let mut keys = self.write_lock_reverse_map();
         if keys.len() <= id {
             keys.resize(id + 1, Default::default())
         }
         keys[id] = arc_name;
-        map_entry.insert(id);
+        map_entry.insert_entry(id);
     }
 
-    pub fn has_name(&self, id: usize) -> bool {
-        let guard = self.reverse_map.read_recursive();
+    pub fn has_id(&self, id: usize) -> bool {
+        let guard = self.read_lock_reverse_map();
         guard.get(id).is_some()
     }
 
     pub fn get_name(&self, id: usize) -> ArcStr {
-        let guard = self.reverse_map.read_recursive();
+        let guard = self.read_lock_reverse_map();
         guard
             .get(id)
             .cloned()
             .expect("internal ids should always be mapped to a name")
     }
 
-    pub fn get_keys(&self) -> ArcReadLockedVec<ArcStr> {
-        ArcReadLockedVec {
-            guard: self.reverse_map.read_arc_recursive(),
+    /// Public ids
+    pub fn ids(&self) -> impl Iterator<Item = usize> {
+        self.num_private_fields..self.num_all_fields()
+    }
+
+    /// All ids, including private fields
+    pub fn all_ids(&self) -> impl Iterator<Item = usize> {
+        0..self.num_all_fields()
+    }
+
+    /// Public keys
+    pub fn keys(&self) -> PublicKeys<ArcStr> {
+        PublicKeys {
+            guard: self.read_arc_lock_reverse_map(),
+            num_private_fields: self.num_private_fields,
+        }
+    }
+
+    /// All keys including private fields
+    pub fn all_keys(&self) -> AllKeys<ArcStr> {
+        AllKeys {
+            guard: self.read_arc_lock_reverse_map(),
         }
     }
 
-    pub fn get_values(&self) -> Vec<usize> {
-        self.map.iter().map(|entry| *entry.value()).collect()
+    pub fn num_all_fields(&self) -> usize {
+        self.read_lock_reverse_map().len()
+    }
+
+    pub fn num_fields(&self) -> usize {
+        self.map.read_recursive().len()
+    }
+
+    pub fn num_private_fields(&self) -> usize {
+        self.num_private_fields
+    }
+}
+
+#[derive(Debug)]
+pub struct AllKeys<T> {
+    pub(crate) guard: ArcRwLockReadGuard<Vec<T>>,
+}
+
+impl<T> Deref for AllKeys<T> {
+    type Target = [T];
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        self.guard.deref().deref()
+    }
+}
+
+impl<T: Clone> IntoIterator for AllKeys<T> {
+    type Item = T;
+    type IntoIter = LockedIter<T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        let guard = self.guard;
+        let len = guard.len();
+        let pos = 0;
+        LockedIter { guard, pos, len }
+    }
+}
+
+pub struct PublicKeys<T> {
+    guard: ArcRwLockReadGuard<Vec<T>>,
+    num_private_fields: usize,
+}
+
+impl<T> PublicKeys<T> {
+    fn items(&self) -> &[T] {
+        &self.guard[self.num_private_fields..]
+    }
+    pub fn iter(&self) -> impl Iterator<Item = &T> + '_ {
+        self.items().iter()
     }
 
     pub fn len(&self) -> usize {
-        self.reverse_map.read_recursive().len()
+        self.items().len()
     }
 
     pub fn is_empty(&self) -> bool {
-        self.reverse_map.read_recursive().is_empty()
+        self.items().is_empty()
+    }
+}
+
+impl<T: Clone> IntoIterator for PublicKeys<T> {
+    type Item = T;
+    type IntoIter = LockedIter<T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        let guard = self.guard;
+        let len = guard.len();
+        let pos = self.num_private_fields;
+        LockedIter { guard, pos, len }
+    }
+}
+
+pub struct LockedIter<T> {
+    guard: ArcRwLockReadGuard<Vec<T>>,
+    pos: usize,
+    len: usize,
+}
+
+impl<T: Clone> Iterator for LockedIter<T> {
+    type Item = T;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.pos < self.len {
+            let next_val = Some(self.guard[self.pos].clone());
+            self.pos += 1;
+            next_val
+        } else {
+            None
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let len = self.len - self.pos;
+        (len, Some(len))
     }
 }
 
+impl<T: Clone> ExactSizeIterator for LockedIter<T> {}
+
 #[cfg(test)]
 mod test {
     use crate::core::storage::dict_mapper::DictMapper;
-    use proptest::{arbitrary::any, prop_assert, proptest};
+    use proptest::prelude::*;
     use rand::seq::SliceRandom;
     use rayon::prelude::*;
     use std::collections::HashMap;
@@ -199,9 +435,39 @@ mod test {
         assert_eq!(mapper.get_or_create_id("test").inner(), 0);
     }
 
+    #[test]
+    fn test_dict_mapper_deep_clone() {
+        let mapper = DictMapper::new_with_private_fields(["_private"]);
+        let alpha_id = mapper.get_or_create_id("alpha").inner();
+        let beta_id = mapper.get_or_create_id("beta").inner();
+
+        let cloned = mapper.deep_clone();
+
+        assert_eq!(cloned.num_private_fields(), mapper.num_private_fields());
+        assert_eq!(cloned.get_id("alpha"), Some(alpha_id));
+        assert_eq!(cloned.get_id("beta"), Some(beta_id));
+        assert_eq!(cloned.get_name(alpha_id).as_ref(), "alpha");
+        assert_eq!(cloned.get_name(beta_id).as_ref(), "beta");
+        assert_eq!(cloned.num_fields(), mapper.num_fields());
+        assert_eq!(
+            cloned.all_keys().into_iter().collect::<Vec<_>>(),
+            mapper.all_keys().into_iter().collect::<Vec<_>>()
+        );
+
+        let gamma_id = cloned.get_or_create_id("gamma").inner();
+        assert_eq!(gamma_id, 3);
+        assert!(cloned.contains("gamma"));
+        assert!(!mapper.contains("gamma"));
+
+        let delta_id = mapper.get_or_create_id("delta").inner();
+        assert_eq!(delta_id, 3);
+        assert!(mapper.contains("delta"));
+        assert!(!cloned.contains("delta"));
+    }
+
     #[test]
     fn check_dict_mapper_concurrent_write() {
-        proptest!(|(write in any::<Vec<String>>())| {
+        proptest!(|(write: Vec<String>)| {
             let n = 100;
             let mapper: DictMapper = DictMapper::default();
 
@@ -210,7 +476,7 @@ mod test {
                 .into_par_iter()
                 .map(|_| {
                     let mut ids: HashMap<String, usize> = Default::default();
-                    let mut rng = rand::thread_rng();
+                    let mut rng = rand::rng();
                     let mut write_s = write.clone();
                     write_s.shuffle(&mut rng);
                     for s in write_s {
@@ -223,8 +489,8 @@ mod test {
 
             // check that all maps are the same and that all strings have been assigned an id
             let res_0 = &res[0];
-            prop_assert!(res[1..n].iter().all(|v| res_0 == v) && write.iter().all(|v| mapper.get_id(v).is_some()))
-        })
+            prop_assert!(res[1..n].iter().all(|v| res_0 == v) && write.iter().all(|v| mapper.get_id(v).is_some()));
+        });
     }
 
     // map 5 strings to 5 ids from 4 threads concurrently 1000 times
diff --git a/raphtory-api/src/core/storage/locked_vec.rs b/raphtory-api/src/core/storage/locked_vec.rs
index c15f6fce59..8b13789179 100644
--- a/raphtory-api/src/core/storage/locked_vec.rs
+++ b/raphtory-api/src/core/storage/locked_vec.rs
@@ -1,55 +1 @@
-use crate::core::storage::ArcRwLockReadGuard;
-use std::ops::Deref;
 
-#[derive(Debug)]
-pub struct ArcReadLockedVec<T> {
-    pub(crate) guard: ArcRwLockReadGuard<Vec<T>>,
-}
-
-impl<T> Deref for ArcReadLockedVec<T> {
-    type Target = Vec<T>;
-
-    #[inline]
-    fn deref(&self) -> &Self::Target {
-        self.guard.deref()
-    }
-}
-
-impl<T: Clone> IntoIterator for ArcReadLockedVec<T> {
-    type Item = T;
-    type IntoIter = LockedIter<T>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        let guard = self.guard;
-        let len = guard.len();
-        let pos = 0;
-        LockedIter { guard, pos, len }
-    }
-}
-
-pub struct LockedIter<T> {
-    guard: ArcRwLockReadGuard<Vec<T>>,
-    pos: usize,
-    len: usize,
-}
-
-impl<T: Clone> Iterator for LockedIter<T> {
-    type Item = T;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        if self.pos < self.len {
-            let next_val = Some(self.guard[self.pos].clone());
-            self.pos += 1;
-            next_val
-        } else {
-            None
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let remaining = self.len - self.pos;
-        (remaining, Some(remaining))
-    }
-}
-
-impl<T: Clone> ExactSizeIterator for LockedIter<T> {}
diff --git a/raphtory-api/src/core/storage/mod.rs b/raphtory-api/src/core/storage/mod.rs
index c198014d22..ad33155ba7 100644
--- a/raphtory-api/src/core/storage/mod.rs
+++ b/raphtory-api/src/core/storage/mod.rs
@@ -1,5 +1,5 @@
 use dashmap::DashMap;
-use rustc_hash::FxHasher;
+use rustc_hash::{FxBuildHasher, FxHasher};
 use std::hash::BuildHasherDefault;
 
 pub mod arc_str;
@@ -9,5 +9,6 @@ pub mod sorted_vec_map;
 pub mod timeindex;
 
 pub type FxDashMap<K, V> = DashMap<K, V, BuildHasherDefault<FxHasher>>;
+pub type FxHashMap<K, V> = std::collections::HashMap<K, V, FxBuildHasher>;
 
 pub type ArcRwLockReadGuard<T> = lock_api::ArcRwLockReadGuard<parking_lot::RawRwLock, T>;
diff --git a/raphtory-api/src/core/utils/time.rs b/raphtory-api/src/core/utils/time.rs
index f81cdc726f..5623cc5f83 100644
--- a/raphtory-api/src/core/utils/time.rs
+++ b/raphtory-api/src/core/utils/time.rs
@@ -148,6 +148,9 @@ impl TryIntoTimeNeedsEventId for &str {}
 
 /// Used to handle automatic injection of event id if not explicitly provided.
 /// In many cases, we will want different behaviour if an event id was provided or not.
+#[derive(
+    Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash, serde::Serialize, serde::Deserialize,
+)]
 pub enum InputTime {
     Simple(i64),
     Indexed(i64, usize),
diff --git a/raphtory-api/src/lib.rs b/raphtory-api/src/lib.rs
index e4b29b9e95..8861afe5fe 100644
--- a/raphtory-api/src/lib.rs
+++ b/raphtory-api/src/lib.rs
@@ -7,7 +7,9 @@ pub mod python;
 pub mod inherit;
 pub mod iter;
 
-#[derive(PartialOrd, PartialEq, Debug)]
+use serde::{Deserialize, Serialize};
+
+#[derive(PartialOrd, PartialEq, Debug, Serialize, Deserialize)]
 pub enum GraphType {
     EventGraph,
     PersistentGraph,
diff --git a/raphtory-api/src/python/arcstr.rs b/raphtory-api/src/python/arcstr.rs
index 7a736bc5fa..89ee16d2d3 100644
--- a/raphtory-api/src/python/arcstr.rs
+++ b/raphtory-api/src/python/arcstr.rs
@@ -22,8 +22,9 @@ impl<'py> IntoPyObject<'py> for &ArcStr {
     }
 }
 
-impl<'source> FromPyObject<'source> for ArcStr {
-    fn extract_bound(ob: &Bound<'source, PyAny>) -> PyResult<Self> {
-        ob.extract::<String>().map(|v| v.into())
+impl<'py> FromPyObject<'_, 'py> for ArcStr {
+    type Error = PyErr;
+    fn extract(obj: Borrowed<'_, 'py, PyAny>) -> Result<Self, Self::Error> {
+        obj.extract::<String>().map(|v| v.into())
     }
 }
diff --git a/raphtory-api/src/python/direction.rs b/raphtory-api/src/python/direction.rs
index 6f367a85c6..4211eac4f3 100644
--- a/raphtory-api/src/python/direction.rs
+++ b/raphtory-api/src/python/direction.rs
@@ -1,8 +1,9 @@
 use crate::core::Direction;
 use pyo3::{exceptions::PyTypeError, prelude::*};
 
-impl<'source> FromPyObject<'source> for Direction {
-    fn extract_bound(ob: &Bound<'source, PyAny>) -> PyResult<Self> {
+impl<'py> FromPyObject<'_, 'py> for Direction {
+    type Error = PyErr;
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
         let value: &str = ob.extract()?;
         match value {
             "out" => Ok(Direction::OUT),
diff --git a/raphtory-api/src/python/gid.rs b/raphtory-api/src/python/gid.rs
index 4883aafcbc..6c44aa7c28 100644
--- a/raphtory-api/src/python/gid.rs
+++ b/raphtory-api/src/python/gid.rs
@@ -28,11 +28,12 @@ impl<'py> IntoPyObject<'py> for &GID {
     }
 }
 
-impl<'source> FromPyObject<'source> for GID {
-    fn extract_bound(id: &Bound<'source, PyAny>) -> PyResult<Self> {
-        id.extract::<String>()
+impl<'py> FromPyObject<'_, 'py> for GID {
+    type Error = PyErr;
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
+        ob.extract::<String>()
             .map(GID::Str)
-            .or_else(|_| id.extract::<u64>().map(GID::U64))
+            .or_else(|_| ob.extract::<u64>().map(GID::U64))
             .map_err(|_| {
                 let msg = "IDs need to be strings or an unsigned integers";
                 PyTypeError::new_err(msg)
diff --git a/raphtory-api/src/python/prop.rs b/raphtory-api/src/python/prop.rs
index d00acc2f1e..4560904a11 100644
--- a/raphtory-api/src/python/prop.rs
+++ b/raphtory-api/src/python/prop.rs
@@ -3,11 +3,12 @@ use crate::core::{
     storage::arc_str::ArcStr,
 };
 use bigdecimal::BigDecimal;
+use chrono::{DateTime, NaiveDateTime, Utc};
 use pyo3::{
     exceptions::PyTypeError,
     prelude::*,
     pybacked::PyBackedStr,
-    sync::GILOnceCell,
+    sync::PyOnceLock,
     types::{PyBool, PyDict, PyType},
     Bound, FromPyObject, IntoPyObject, IntoPyObjectExt, Py, PyAny, PyErr, PyResult, Python,
 };
@@ -15,7 +16,6 @@ use pyo3_arrow::PyDataType;
 use rustc_hash::FxHashMap;
 use std::{collections::HashMap, ops::Deref, str::FromStr, sync::Arc};
 
-#[cfg(feature = "arrow")]
 mod array_ext {
     use pyo3::{intern, prelude::*, types::PyTuple};
     use pyo3_arrow::PyArray;
@@ -34,10 +34,11 @@ mod array_ext {
     }
 }
 
-#[cfg(feature = "arrow")]
-use {crate::core::entities::properties::prop::PropArray, array_ext::*, pyo3_arrow::PyArray};
+use crate::core::entities::properties::prop::PropArray;
+use array_ext::*;
+use pyo3_arrow::PyArray;
 
-static DECIMAL_CLS: GILOnceCell<Py<PyType>> = GILOnceCell::new();
+static DECIMAL_CLS: PyOnceLock<Py<PyType>> = PyOnceLock::new();
 
 fn get_decimal_cls(py: Python<'_>) -> PyResult<&Bound<'_, PyType>> {
     DECIMAL_CLS.import(py, "decimal", "Decimal")
@@ -59,18 +60,45 @@ impl<'py> IntoPyObject<'py> for Prop {
             Prop::F64(f64) => f64.into_pyobject(py)?.into_any(),
             Prop::DTime(dtime) => dtime.into_pyobject(py)?.into_any(),
             Prop::NDTime(ndtime) => ndtime.into_pyobject(py)?.into_any(),
-            #[cfg(feature = "arrow")]
-            Prop::Array(blob) => {
-                if let Some(arr_ref) = blob.into_array_ref() {
-                    PyArray::from_array_ref(arr_ref).into_pyarrow(py)?
-                } else {
-                    py.None().into_bound(py)
-                }
+            Prop::I32(v) => v.into_pyobject(py)?.into_any(),
+            Prop::U32(v) => v.into_pyobject(py)?.into_any(),
+            Prop::F32(v) => v.into_pyobject(py)?.into_any(),
+            Prop::List(PropArray::Array(arr_ref)) => {
+                PyArray::from_array_ref(arr_ref).into_pyarrow(py)?
             }
+            Prop::List(PropArray::Vec(v)) => v.into_pyobject(py)?.into_any(), // Fixme: optimise the clone here?
+            Prop::Map(v) => v.deref().clone().into_pyobject(py)?.into_any(),
+            Prop::Decimal(d) => {
+                let decl_cls = get_decimal_cls(py)?;
+                decl_cls.call1((d.to_string(),))?
+            }
+        })
+    }
+}
+
+impl<'a, 'py: 'a> IntoPyObject<'py> for &'a Prop {
+    type Target = PyAny;
+    type Output = Bound<'py, PyAny>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        Ok(match self {
+            Prop::Str(s) => s.into_pyobject(py)?.into_any(),
+            Prop::Bool(bool) => bool.into_bound_py_any(py)?,
+            Prop::U8(u8) => u8.into_pyobject(py)?.into_any(),
+            Prop::U16(u16) => u16.into_pyobject(py)?.into_any(),
+            Prop::I64(i64) => i64.into_pyobject(py)?.into_any(),
+            Prop::U64(u64) => u64.into_pyobject(py)?.into_any(),
+            Prop::F64(f64) => f64.into_pyobject(py)?.into_any(),
+            Prop::DTime(dtime) => dtime.into_pyobject(py)?.into_any(),
+            Prop::NDTime(ndtime) => ndtime.into_pyobject(py)?.into_any(),
             Prop::I32(v) => v.into_pyobject(py)?.into_any(),
             Prop::U32(v) => v.into_pyobject(py)?.into_any(),
             Prop::F32(v) => v.into_pyobject(py)?.into_any(),
-            Prop::List(v) => v.deref().clone().into_pyobject(py)?.into_any(), // Fixme: optimise the clone here?
+            Prop::List(PropArray::Array(arr_ref)) => {
+                PyArray::from_array_ref(arr_ref.clone()).into_pyarrow(py)?
+            }
+            Prop::List(PropArray::Vec(v)) => v.into_pyobject(py)?.into_any(),
             Prop::Map(v) => v.deref().clone().into_pyobject(py)?.into_any(),
             Prop::Decimal(d) => {
                 let decl_cls = get_decimal_cls(py)?;
@@ -80,81 +108,239 @@ impl<'py> IntoPyObject<'py> for Prop {
     }
 }
 
-#[pyclass(name = "Prop", module = "raphtory")]
+#[pyclass(name = "Prop", module = "raphtory", eq)]
+#[derive(PartialEq)]
 pub struct PyProp(pub Prop);
 
 #[pymethods]
 impl PyProp {
+    /// Construct a `Prop` holding an unsigned 8-bit integer.
+    ///
+    /// Arguments:
+    ///     value (int): the value to wrap.
+    ///
+    /// Returns:
+    ///     Prop:
     #[staticmethod]
     pub fn u8(value: u8) -> Self {
         PyProp(Prop::U8(value))
     }
 
+    /// Construct a `Prop` holding an unsigned 16-bit integer.
+    ///
+    /// Arguments:
+    ///     value (int): the value to wrap.
+    ///
+    /// Returns:
+    ///     Prop:
     #[staticmethod]
     pub fn u16(value: u16) -> Self {
         PyProp(Prop::U16(value))
     }
 
+    /// Construct a `Prop` holding an unsigned 32-bit integer.
+    ///
+    /// Arguments:
+    ///     value (int): the value to wrap.
+    ///
+    /// Returns:
+    ///     Prop:
     #[staticmethod]
     pub fn u32(value: u32) -> Self {
         PyProp(Prop::U32(value))
     }
 
+    /// Construct a `Prop` holding an unsigned 64-bit integer.
+    ///
+    /// Arguments:
+    ///     value (int): the value to wrap.
+    ///
+    /// Returns:
+    ///     Prop:
     #[staticmethod]
     pub fn u64(value: u64) -> Self {
         PyProp(Prop::U64(value))
     }
 
+    /// Construct a `Prop` holding a signed 32-bit integer.
+    ///
+    /// Arguments:
+    ///     value (int): the value to wrap.
+    ///
+    /// Returns:
+    ///     Prop:
     #[staticmethod]
     pub fn i32(value: i32) -> Self {
         PyProp(Prop::I32(value))
     }
 
+    /// Construct a `Prop` holding a signed 64-bit integer.
+    ///
+    /// Arguments:
+    ///     value (int): the value to wrap.
+    ///
+    /// Returns:
+    ///     Prop:
     #[staticmethod]
     pub fn i64(value: i64) -> Self {
         PyProp(Prop::I64(value))
     }
 
+    /// Construct a `Prop` holding a 32-bit float.
+    ///
+    /// Arguments:
+    ///     value (float): the value to wrap.
+    ///
+    /// Returns:
+    ///     Prop:
     #[staticmethod]
     pub fn f32(value: f32) -> Self {
         PyProp(Prop::F32(value))
     }
 
+    /// Construct a `Prop` holding a 64-bit float.
+    ///
+    /// Arguments:
+    ///     value (float): the value to wrap.
+    ///
+    /// Returns:
+    ///     Prop:
     #[staticmethod]
     pub fn f64(value: f64) -> Self {
         PyProp(Prop::F64(value))
     }
 
+    /// Construct a `Prop` holding a string.
+    ///
+    /// Arguments:
+    ///     value (str): the value to wrap.
+    ///
+    /// Returns:
+    ///     Prop:
     #[staticmethod]
     pub fn str(value: &str) -> Self {
         PyProp(Prop::str(value))
     }
 
+    /// Construct a `Prop` holding a boolean.
+    ///
+    /// Arguments:
+    ///     value (bool): the value to wrap.
+    ///
+    /// Returns:
+    ///     Prop:
     #[staticmethod]
     pub fn bool(value: bool) -> Self {
         PyProp(Prop::Bool(value))
     }
 
+    /// Construct a `Prop` holding a list of values.
+    ///
+    /// Arguments:
+    ///     values (list): the values to wrap.
+    ///
+    /// Returns:
+    ///     Prop:
     #[staticmethod]
     pub fn list(values: &Bound<'_, PyAny>) -> PyResult<Self> {
         let elems: Vec<Prop> = values.extract()?;
-        Ok(PyProp(Prop::List(Arc::new(elems))))
+        Ok(PyProp(Prop::list(elems)))
     }
 
+    /// Construct a `Prop` holding a string-keyed map of values.
+    ///
+    /// Arguments:
+    ///     dict (dict[str, Any]): the map to wrap.
+    ///
+    /// Returns:
+    ///     Prop:
     #[staticmethod]
     pub fn map(dict: Bound<'_, PyDict>) -> PyResult<Self> {
         let items: HashMap<String, Prop> = dict.extract()?;
 
-        let mut map: FxHashMap<ArcStr, Prop> =
-            FxHashMap::with_capacity_and_hasher(items.len(), Default::default());
-
-        for (k, v) in items {
-            map.insert(ArcStr::from(k), v);
-        }
+        let map: FxHashMap<ArcStr, Prop> = items
+            .into_iter()
+            .map(|(k, v)| (ArcStr::from(k), v))
+            .collect();
 
         Ok(PyProp(Prop::Map(Arc::new(map))))
     }
 
+    /// Construct a `Prop` holding a timezone-aware datetime (stored as UTC).
+    /// Naive datetimes are accepted and interpreted as UTC, matching the
+    /// convention used elsewhere in Raphtory's time inputs.
+    ///
+    /// Arguments:
+    ///     value (datetime): a datetime. Naive datetimes are treated as UTC.
+    ///
+    /// Returns:
+    ///     Prop:
+    #[staticmethod]
+    pub fn aware_datetime(value: &Bound<'_, PyAny>) -> PyResult<Self> {
+        if let Ok(dt) = value.extract::<DateTime<Utc>>() {
+            return Ok(PyProp(Prop::DTime(dt)));
+        }
+        if let Ok(naive) = value.extract::<NaiveDateTime>() {
+            return Ok(PyProp(Prop::DTime(naive.and_utc())));
+        }
+        Err(PyTypeError::new_err(format!(
+            "Could not convert {value:?} to a datetime"
+        )))
+    }
+
+    /// Construct a `Prop` holding a naive (timezone-unaware) datetime.
+    ///
+    /// Arguments:
+    ///     value (datetime): the value to wrap (any tz info is dropped).
+    ///
+    /// Returns:
+    ///     Prop:
+    #[staticmethod]
+    pub fn naive_datetime(value: NaiveDateTime) -> Self {
+        PyProp(Prop::NDTime(value))
+    }
+
+    /// Construct a `Prop` holding an arbitrary-precision decimal.
+    ///
+    /// Arguments:
+    ///     value (Decimal | str | int | float): the value to wrap. Strings must
+    ///         parse as a decimal. Note that floats only have ~15-17 digits of
+    ///         precision — pass a string or `decimal.Decimal` for higher precision.
+    ///
+    /// Returns:
+    ///     Prop:
+    #[staticmethod]
+    pub fn decimal(value: &Bound<'_, PyAny>) -> PyResult<Self> {
+        let bd = if value.get_type().name()?.contains("Decimal")? {
+            // decimal.Decimal — go via its str representation for full precision.
+            let s = value.str()?.to_cow()?.into_owned();
+            BigDecimal::from_str(&s)
+                .map_err(|_| PyTypeError::new_err(format!("Could not convert {s} to Decimal")))?
+        } else if let Ok(i) = value.extract::<i64>() {
+            BigDecimal::from(i)
+        } else if let Ok(u) = value.extract::<u64>() {
+            BigDecimal::from(u)
+        } else if let Ok(f) = value.extract::<f64>() {
+            BigDecimal::try_from(f)
+                .map_err(|_| PyTypeError::new_err(format!("Could not convert {f} to Decimal")))?
+        } else if let Ok(s) = value.extract::<String>() {
+            BigDecimal::from_str(&s)
+                .map_err(|_| PyTypeError::new_err(format!("Could not convert {s} to Decimal")))?
+        } else {
+            return Err(PyTypeError::new_err(format!(
+                "Could not convert {:?} to Decimal",
+                value
+            )));
+        };
+        let prop = Prop::try_from_bd(bd)
+            .map_err(|_| PyTypeError::new_err(format!("Decimal too large: {value:?}")))?;
+        Ok(PyProp(prop))
+    }
+
+    /// Returns the `PropType` of the wrapped value.
+    ///
+    /// Returns:
+    ///     PropType:
     pub fn dtype(&self) -> PropType {
         self.0.dtype()
     }
@@ -162,11 +348,19 @@ impl PyProp {
     pub fn __repr__(&self) -> String {
         format!("{}", self.0)
     }
+
+    fn __hash__(&self) -> u64 {
+        use std::hash::{DefaultHasher, Hash, Hasher};
+        let mut hasher = DefaultHasher::new();
+        self.0.hash(&mut hasher);
+        hasher.finish()
+    }
 }
 
 // Manually implemented to make sure we don't end up with f32/i32/u32 from python ints/floats
-impl<'source> FromPyObject<'source> for Prop {
-    fn extract_bound(ob: &Bound<'source, PyAny>) -> PyResult<Self> {
+impl<'py> FromPyObject<'_, 'py> for Prop {
+    type Error = PyErr;
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
         if let Ok(pyref) = ob.extract::<PyRef<PyProp>>() {
             return Ok(pyref.0.clone());
         }
@@ -213,15 +407,12 @@ impl<'source> FromPyObject<'source> for Prop {
         if let Ok(s) = ob.extract::<String>() {
             return Ok(Prop::Str(s.into()));
         }
-
-        #[cfg(feature = "arrow")]
         if let Ok(arrow) = ob.extract::<PyArray>() {
             let (arr, _) = arrow.into_inner();
-            return Ok(Prop::Array(PropArray::Array(arr)));
+            return Ok(Prop::List(PropArray::Array(arr)));
         }
-
-        if let Ok(list) = ob.extract() {
-            return Ok(Prop::List(Arc::new(list)));
+        if let Ok(list) = ob.extract::<Vec<Prop>>() {
+            return Ok(Prop::List(PropArray::Vec(list.into())));
         }
 
         if let Ok(map) = ob.extract() {
@@ -229,8 +420,9 @@ impl<'source> FromPyObject<'source> for Prop {
         }
 
         Err(PyTypeError::new_err(format!(
-            "Could not convert {:?} to Prop",
-            ob
+            "Could not convert {:?} of type {:?} to Prop",
+            ob,
+            ob.get_type()
         )))
     }
 }
@@ -244,81 +436,151 @@ pub struct PyPropType(pub PropType);
 
 #[pymethods]
 impl PyPropType {
+    /// Unsigned 8-bit integer type.
+    ///
+    /// Returns:
+    ///     PropType:
     #[staticmethod]
     pub fn u8() -> PropType {
         PropType::U8
     }
 
+    /// Unsigned 16-bit integer type.
+    ///
+    /// Returns:
+    ///     PropType:
     #[staticmethod]
     pub fn u16() -> PropType {
         PropType::U16
     }
 
+    /// Unsigned 32-bit integer type.
+    ///
+    /// Returns:
+    ///     PropType:
     #[staticmethod]
     pub fn u32() -> PropType {
         PropType::U32
     }
 
+    /// Unsigned 64-bit integer type.
+    ///
+    /// Returns:
+    ///     PropType:
     #[staticmethod]
     pub fn u64() -> PropType {
         PropType::U64
     }
 
+    /// Signed 32-bit integer type.
+    ///
+    /// Returns:
+    ///     PropType:
     #[staticmethod]
     pub fn i32() -> PropType {
         PropType::I32
     }
 
+    /// Signed 64-bit integer type.
+    ///
+    /// Returns:
+    ///     PropType:
     #[staticmethod]
     pub fn i64() -> PropType {
         PropType::I64
     }
 
+    /// 32-bit float type.
+    ///
+    /// Returns:
+    ///     PropType:
     #[staticmethod]
     pub fn f32() -> PropType {
         PropType::F32
     }
 
+    /// 64-bit float type.
+    ///
+    /// Returns:
+    ///     PropType:
     #[staticmethod]
     pub fn f64() -> PropType {
         PropType::F64
     }
 
+    /// String type.
+    ///
+    /// Returns:
+    ///     PropType:
     #[staticmethod]
     pub fn str() -> PropType {
         PropType::Str
     }
 
+    /// Boolean type.
+    ///
+    /// Returns:
+    ///     PropType:
     #[staticmethod]
     pub fn bool() -> PropType {
         PropType::Bool
     }
 
+    /// Naive datetime type (timezone-unaware).
+    ///
+    /// Returns:
+    ///     PropType:
     #[staticmethod]
     pub fn naive_datetime() -> PropType {
         PropType::NDTime
     }
 
+    /// Datetime type (timezone-aware).
+    ///
+    /// Returns:
+    ///     PropType:
     #[staticmethod]
     pub fn datetime() -> PropType {
         PropType::DTime
     }
 
+    /// Arbitrary-precision decimal type with a fixed scale (number of digits
+    /// after the decimal point).
+    ///
+    /// Arguments:
+    ///     scale (int): the number of digits after the decimal point.
+    ///
+    /// Returns:
+    ///     PropType:
+    #[staticmethod]
+    pub fn decimal(scale: i64) -> PropType {
+        PropType::Decimal { scale }
+    }
+
+    /// List type with a single element type.
+    ///
+    /// Arguments:
+    ///     p (PropType): element type.
+    ///
+    /// Returns:
+    ///     PropType:
     #[staticmethod]
     pub fn list(p: PropType) -> PropType {
         PropType::List(Box::new(p))
     }
 
+    /// Map type with string keys and typed values.
+    ///
+    /// Arguments:
+    ///     hash_map (dict[str, PropType]): mapping from key name to value type.
+    ///
+    /// Returns:
+    ///     PropType:
     #[staticmethod]
     pub fn map(hash_map: HashMap<String, PropType>) -> PropType {
         PropType::Map(Arc::new(hash_map))
     }
 
-    #[staticmethod]
-    pub fn array(p: PropType) -> PropType {
-        PropType::Array(Box::new(p))
-    }
-
     fn __repr__(&self) -> String {
         format!("PropType.{}", self.0)
     }
@@ -342,9 +604,10 @@ impl<'py> IntoPyObject<'py> for PropType {
     }
 }
 
-impl<'source> FromPyObject<'source> for PropType {
-    fn extract_bound(ob: &Bound<'source, PyAny>) -> PyResult<Self> {
-        if let Ok(prop_type) = ob.downcast::<PyPropType>() {
+impl<'source> FromPyObject<'_, 'source> for PropType {
+    type Error = PyErr;
+    fn extract(ob: Borrowed<'_, 'source, PyAny>) -> PyResult<Self> {
+        if let Ok(prop_type) = ob.cast::<PyPropType>() {
             Ok(prop_type.get().0.clone())
         } else if let Ok(prop_type_str) = ob.extract::<PyBackedStr>() {
             match prop_type_str.deref().to_ascii_lowercase().as_str() {
diff --git a/raphtory-api/src/python/timeindex.rs b/raphtory-api/src/python/timeindex.rs
index 1dcb3774a2..067bcfe6ed 100644
--- a/raphtory-api/src/python/timeindex.rs
+++ b/raphtory-api/src/python/timeindex.rs
@@ -24,9 +24,10 @@ impl<'py> IntoPyObject<'py> for EventTime {
     }
 }
 
-impl<'source> FromPyObject<'source> for EventTime {
-    fn extract_bound(time: &Bound<'source, PyAny>) -> PyResult<Self> {
-        InputTime::extract_bound(time).map(|input_time| input_time.as_time())
+impl<'source> FromPyObject<'_, 'source> for EventTime {
+    type Error = PyErr;
+    fn extract(time: Borrowed<'_, 'source, PyAny>) -> PyResult<Self> {
+        InputTime::extract(time).map(|input_time| input_time.as_time())
     }
 }
 
@@ -55,13 +56,14 @@ impl EventTimeComponent {
     }
 }
 
-impl<'source> FromPyObject<'source> for EventTimeComponent {
-    fn extract_bound(component: &Bound<'source, PyAny>) -> PyResult<Self> {
+impl<'source> FromPyObject<'_, 'source> for EventTimeComponent {
+    type Error = PyErr;
+    fn extract(component: Borrowed<'_, 'source, PyAny>) -> PyResult<Self> {
         extract_time_index_component(component).map_err(|e| match e {
             ParsingError::Matched(err) => err,
             ParsingError::Unmatched => {
                 let message = format!(
-                    "Time component '{component}' must be a str, datetime, float, or an integer."
+                    "Time component '{component:?}' must be a str, datetime, float, or an integer."
                 );
                 PyTypeError::new_err(message)
             }
@@ -73,8 +75,8 @@ enum ParsingError {
     Unmatched,
 }
 
-fn extract_time_index_component<'source>(
-    component: &Bound<'source, PyAny>,
+fn extract_time_index_component(
+    component: Borrowed<'_, '_, PyAny>,
 ) -> Result<EventTimeComponent, ParsingError> {
     if let Ok(string) = component.extract::<String>() {
         let timestamp = string.as_str();
@@ -108,7 +110,7 @@ fn extract_time_index_component<'source>(
             parsed_datetime.and_utc().timestamp_millis(),
         ));
     }
-    if let Ok(py_datetime) = component.downcast::<PyDateTime>() {
+    if let Ok(py_datetime) = component.cast::<PyDateTime>() {
         let time = (py_datetime
             .call_method0("timestamp")
             .map_err(ParsingError::Matched)?
@@ -129,7 +131,7 @@ fn extract_time_index_component<'source>(
             naive_dt.and_utc().timestamp_millis(),
         ));
     }
-    if let Ok(py_date) = component.downcast::<PyDate>() {
+    if let Ok(py_date) = component.cast::<PyDate>() {
         let year: i32 = py_date.get_year();
         let month: u32 = py_date.get_month() as u32;
         let day: u32 = py_date.get_day() as u32;
@@ -154,7 +156,7 @@ fn extract_time_index_component<'source>(
 }
 
 fn parse_email_timestamp(timestamp: &str) -> PyResult<EventTime> {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let email_utils = PyModule::import(py, "email.utils")?;
         let datetime = email_utils.call_method1("parsedate_to_datetime", (timestamp,))?;
         let py_seconds = datetime.call_method1("timestamp", ())?;
@@ -163,8 +165,8 @@ fn parse_email_timestamp(timestamp: &str) -> PyResult<EventTime> {
     })
 }
 
-/// Raphtory’s EventTime.
-/// Represents a unique timepoint in the graph’s history as (timestamp, event_id).
+/// Raphtory's EventTime.
+/// Represents a unique timepoint in the graph's history as (timestamp, event_id).
 ///
 /// - timestamp: Number of milliseconds since the Unix epoch.
 /// - event_id: ID used for ordering between equal timestamps.
@@ -174,6 +176,10 @@ fn parse_email_timestamp(timestamp: &str) -> PyResult<EventTime> {
 /// EventTime can be converted into a timestamp or a Python datetime, and compared
 /// either by timestamp (against ints/floats/datetimes/strings), by tuple of (timestamp, event_id),
 /// or against another EventTime.
+///
+/// Arguments:
+///     timestamp (int | float | datetime | str): A time input convertible to an EventTime.
+///     event_id (int | float | datetime | str | None): Optionally, specify the event id. Defaults to None.
 #[pyclass(name = "EventTime", module = "raphtory", frozen)]
 #[derive(Debug, Clone, Copy, Serialize, PartialEq, Ord, PartialOrd, Eq)]
 pub struct PyEventTime {
@@ -365,7 +371,7 @@ impl PyOptionalEventTime {
     /// Returns the timestamp in milliseconds since the Unix epoch if an EventTime is contained, or else None.
     ///
     /// Returns:
-    ///     int | None: Milliseconds since the Unix epoch.
+    ///     Optional[int]: Milliseconds since the Unix epoch.
     #[getter]
     pub fn t(&self) -> Option<i64> {
         self.inner.map(|t| t.t())
@@ -374,7 +380,7 @@ impl PyOptionalEventTime {
     /// Returns the UTC datetime representation of this EventTime's timestamp if an EventTime is contained, or else None.
     ///
     /// Returns:
-    ///     datetime | None: The UTC datetime.
+    ///     Optional[datetime]: The UTC datetime.
     ///
     /// Raises:
     ///     TimeError: Returns TimeError on timestamp conversion errors (e.g. out-of-range timestamp).
@@ -386,7 +392,7 @@ impl PyOptionalEventTime {
     /// Returns the event id used to order events within the same timestamp if an EventTime is contained, or else None.
     ///
     /// Returns:
-    ///     int | None: The event id.
+    ///     Optional[int]: The event id.
     #[getter]
     pub fn event_id(&self) -> Option<usize> {
         self.inner.map(|t| t.i())
@@ -411,7 +417,7 @@ impl PyOptionalEventTime {
     /// Returns the contained EventTime if it exists, or else None.
     ///
     /// Returns:
-    ///     EventTime | None:
+    ///     Optional[EventTime]:
     pub fn get_event_time(&self) -> Option<EventTime> {
         self.inner
     }
@@ -419,7 +425,7 @@ impl PyOptionalEventTime {
     /// Return this entry as a tuple of (timestamp, event_id), where the timestamp is in milliseconds if an EventTime is contained, or else None.
     ///
     /// Returns:
-    ///     tuple[int,int] | None: (timestamp, event_id).
+    ///     Optional[tuple[int, int]]: (timestamp, event_id).
     #[getter]
     pub fn as_tuple(&self) -> Option<(i64, usize)> {
         self.inner.map(|t| t.as_tuple())
@@ -504,9 +510,10 @@ impl From<PyOptionalEventTime> for Option<EventTime> {
     }
 }
 
-impl<'source> FromPyObject<'source> for InputTime {
-    fn extract_bound(input: &Bound<'source, PyAny>) -> PyResult<Self> {
-        if let Ok(py_time) = input.downcast::<PyEventTime>() {
+impl<'source> FromPyObject<'_, 'source> for InputTime {
+    type Error = PyErr;
+    fn extract(input: Borrowed<'_, 'source, PyAny>) -> PyResult<Self> {
+        if let Ok(py_time) = input.cast::<PyEventTime>() {
             return Ok(py_time.get().try_into_input_time()?);
         } else if let Ok(opt_py_time) = input.extract::<PyOptionalEventTime>() {
             return match opt_py_time.inner {
@@ -515,9 +522,9 @@ impl<'source> FromPyObject<'source> for InputTime {
             };
         }
         // Handle list/tuple case: [timestamp, event_id]
-        if input.downcast::<PyTuple>().is_ok() || input.downcast::<PyList>().is_ok() {
+        if input.cast::<PyTuple>().is_ok() || input.cast::<PyList>().is_ok() {
             let py = input.py();
-            if let Ok(items) = input.extract::<Vec<PyObject>>() {
+            if let Ok(items) = input.extract::<Vec<Py<PyAny>>>() {
                 let len = items.len();
                 if len != 2 {
                     return Err(PyTypeError::new_err(format!(
@@ -525,19 +532,19 @@ impl<'source> FromPyObject<'source> for InputTime {
                         len
                     )));
                 }
-                let first = items[0].bind(py);
-                let second = items[1].bind(py);
+                let first = items[0].bind_borrowed(py);
+                let second = items[1].bind_borrowed(py);
                 let first_entry = extract_time_index_component(first).map_err(|e| match e {
                     ParsingError::Matched(err) => err,
                     ParsingError::Unmatched => {
-                        let message = format!("Time component '{first}' must be a str, datetime, float, or an integer.");
+                        let message = format!("Time component '{first:?}' must be a str, datetime, float, or an integer.");
                         PyTypeError::new_err(message)
                     }
                 })?;
                 let second_entry = extract_time_index_component(second).map_err(|e| match e {
                     ParsingError::Matched(err) => err,
                     ParsingError::Unmatched => {
-                        let message = format!("Time component '{second}' must be a str, datetime, float, or an integer.");
+                        let message = format!("Time component '{second:?}' must be a str, datetime, float, or an integer.");
                         PyTypeError::new_err(message)
                     }
                 })?;
@@ -552,7 +559,7 @@ impl<'source> FromPyObject<'source> for InputTime {
             Ok(component) => Ok(InputTime::Simple(component.t())),
             Err(ParsingError::Matched(err)) => Err(err),
             Err(ParsingError::Unmatched) => {
-                let message = format!("Time '{input}' must be a str, datetime, float, integer, or a tuple/list of two of those types.");
+                let message = format!("Time '{input:?}' must be a str, datetime, float, integer, or a tuple/list of two of those types.");
                 Err(PyTypeError::new_err(message))
             }
         }
diff --git a/raphtory-auth-noop/Cargo.toml b/raphtory-auth-noop/Cargo.toml
new file mode 100644
index 0000000000..7b20f3a52c
--- /dev/null
+++ b/raphtory-auth-noop/Cargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "raphtory-auth-noop"
+version.workspace = true
+edition.workspace = true
+
+[dependencies]
diff --git a/raphtory-auth-noop/src/lib.rs b/raphtory-auth-noop/src/lib.rs
new file mode 100644
index 0000000000..12cd021c75
--- /dev/null
+++ b/raphtory-auth-noop/src/lib.rs
@@ -0,0 +1 @@
+pub fn init() {}
diff --git a/raphtory-benchmark/Cargo.toml b/raphtory-benchmark/Cargo.toml
index 0971dbf88f..aa53e69535 100644
--- a/raphtory-benchmark/Cargo.toml
+++ b/raphtory-benchmark/Cargo.toml
@@ -9,7 +9,6 @@ edition = "2021"
 criterion = { workspace = true }
 raphtory = { workspace = true, features = [
     "io",
-    "proto",
     "vectors",
 ] }
 raphtory-api = { workspace = true }
@@ -61,15 +60,12 @@ harness = false
 [[bench]]
 name = "proto_encode"
 harness = false
+required-features = ["proto"]
 
 [[bench]]
 name = "proto_decode"
 harness = false
-
-[[bench]]
-name = "arrow_algobench"
-harness = false
-required-features = ["storage"]
+required-features = ["proto"]
 
 [[bench]]
 name = "search_bench"
@@ -87,4 +83,4 @@ required-features = ["search"]
 
 [features]
 search = ["raphtory/search"]
-storage = ["raphtory/storage"]
+proto = ["raphtory/proto"]
diff --git a/raphtory-benchmark/benches/arrow_algobench.rs b/raphtory-benchmark/benches/arrow_algobench.rs
deleted file mode 100644
index c50db642bf..0000000000
--- a/raphtory-benchmark/benches/arrow_algobench.rs
+++ /dev/null
@@ -1,181 +0,0 @@
-use criterion::{criterion_group, criterion_main};
-
-#[cfg(feature = "storage")]
-pub mod arrow_bench {
-    use criterion::{black_box, BenchmarkId, Criterion, SamplingMode};
-    use raphtory::{
-        algorithms::{
-            centrality::pagerank::unweighted_page_rank,
-            components::weakly_connected_components,
-            metrics::clustering_coefficient::{
-                global_clustering_coefficient::global_clustering_coefficient,
-                local_clustering_coefficient::local_clustering_coefficient,
-            },
-            motifs::local_triangle_count::local_triangle_count,
-        },
-        graphgen::random_attachment::random_attachment,
-        prelude::*,
-    };
-    use raphtory_benchmark::common::bench;
-    use rayon::prelude::*;
-    use tempfile::TempDir;
-
-    pub fn local_triangle_count_analysis(c: &mut Criterion) {
-        let mut group = c.benchmark_group("local_triangle_count");
-        group.sample_size(10);
-        bench(&mut group, "local_triangle_count", None, |b| {
-            let g = raphtory::graph_loader::lotr_graph::lotr_graph();
-            let test_dir = TempDir::new().unwrap();
-            let g = g.persist_as_disk_graph(test_dir.path()).unwrap();
-            let windowed_graph = g.window(i64::MIN, i64::MAX);
-
-            b.iter(|| {
-                let node_ids = windowed_graph.nodes().collect();
-
-                node_ids.into_par_iter().for_each(|v| {
-                    local_triangle_count(&windowed_graph, v).unwrap();
-                });
-            })
-        });
-
-        group.finish();
-    }
-
-    pub fn local_clustering_coefficient_analysis(c: &mut Criterion) {
-        let mut group = c.benchmark_group("local_clustering_coefficient");
-
-        bench(&mut group, "local_clustering_coefficient", None, |b| {
-            let g: Graph = Graph::new();
-
-            let vs = vec![
-                (1, 2, 1),
-                (1, 3, 2),
-                (1, 4, 3),
-                (3, 1, 4),
-                (3, 4, 5),
-                (3, 5, 6),
-                (4, 5, 7),
-                (5, 6, 8),
-                (5, 8, 9),
-                (7, 5, 10),
-                (8, 5, 11),
-                (1, 9, 12),
-                (9, 1, 13),
-                (6, 3, 14),
-                (4, 8, 15),
-                (8, 3, 16),
-                (5, 10, 17),
-                (10, 5, 18),
-                (10, 8, 19),
-                (1, 11, 20),
-                (11, 1, 21),
-                (9, 11, 22),
-                (11, 9, 23),
-            ];
-
-            for (src, dst, t) in &vs {
-                g.add_edge(*t, *src, *dst, NO_PROPS, None).unwrap();
-            }
-
-            let test_dir = TempDir::new().unwrap();
-            let g = g.persist_as_disk_graph(test_dir.path()).unwrap();
-
-            let windowed_graph = g.window(0, 5);
-            b.iter(|| local_clustering_coefficient(&windowed_graph, 1))
-        });
-
-        group.finish();
-    }
-
-    pub fn graphgen_large_clustering_coeff(c: &mut Criterion) {
-        let mut group = c.benchmark_group("graphgen_large_clustering_coeff");
-        // generate graph
-        let graph = Graph::new();
-        let seed: [u8; 32] = [1; 32];
-        random_attachment(&graph, 500000, 4, Some(seed));
-
-        let test_dir = TempDir::new().unwrap();
-        let graph = graph.persist_as_disk_graph(test_dir.path()).unwrap();
-
-        group.sampling_mode(SamplingMode::Flat);
-        group.measurement_time(std::time::Duration::from_secs(60));
-        group.sample_size(10);
-        group.bench_with_input(
-            BenchmarkId::new("graphgen_large_clustering_coeff", &graph),
-            &graph,
-            |b, graph| {
-                b.iter(|| {
-                    let result = global_clustering_coefficient(graph);
-                    black_box(result);
-                });
-            },
-        );
-        group.finish()
-    }
-
-    pub fn graphgen_large_pagerank(c: &mut Criterion) {
-        let mut group = c.benchmark_group("graphgen_large_pagerank");
-        // generate graph
-        let graph = Graph::new();
-        let seed: [u8; 32] = [1; 32];
-        random_attachment(&graph, 500000, 4, Some(seed));
-
-        let test_dir = TempDir::new().unwrap();
-        let graph = graph.persist_as_disk_graph(test_dir.path()).unwrap();
-        group.sampling_mode(SamplingMode::Flat);
-        group.measurement_time(std::time::Duration::from_secs(20));
-        group.sample_size(10);
-        group.bench_with_input(
-            BenchmarkId::new("graphgen_large_pagerank", &graph),
-            &graph,
-            |b, graph| {
-                b.iter(|| {
-                    let result = unweighted_page_rank(graph, Some(100), None, None, true, None);
-                    black_box(result);
-                });
-            },
-        );
-        group.finish()
-    }
-
-    pub fn graphgen_large_concomp(c: &mut Criterion) {
-        let mut group = c.benchmark_group("graphgen_large_concomp");
-        // generate graph
-        let graph = Graph::new();
-        let seed: [u8; 32] = [1; 32];
-        random_attachment(&graph, 500000, 4, Some(seed));
-        let test_dir = TempDir::new().unwrap();
-        let graph = graph.persist_as_disk_graph(test_dir.path()).unwrap();
-
-        group.sampling_mode(SamplingMode::Flat);
-        group.measurement_time(std::time::Duration::from_secs(60));
-        group.sample_size(10);
-        group.bench_with_input(
-            BenchmarkId::new("graphgen_large_concomp", &graph),
-            &graph,
-            |b, graph| {
-                b.iter(|| {
-                    let result = weakly_connected_components(graph);
-                    black_box(result);
-                });
-            },
-        );
-        group.finish()
-    }
-}
-
-#[cfg(feature = "storage")]
-pub use arrow_bench::*;
-
-#[cfg(feature = "storage")]
-criterion_group!(
-    benches,
-    local_triangle_count_analysis,
-    local_clustering_coefficient_analysis,
-    graphgen_large_clustering_coeff,
-    graphgen_large_pagerank,
-    graphgen_large_concomp,
-);
-
-#[cfg(feature = "storage")]
-criterion_main!(benches);
diff --git a/raphtory-benchmark/benches/edge_add.rs b/raphtory-benchmark/benches/edge_add.rs
index ff88954ef1..91de49089e 100644
--- a/raphtory-benchmark/benches/edge_add.rs
+++ b/raphtory-benchmark/benches/edge_add.rs
@@ -1,12 +1,12 @@
 use criterion::{criterion_group, criterion_main, Criterion};
 use rand::{
-    distributions::{Alphanumeric, DistString},
-    thread_rng, Rng,
+    distr::{Alphanumeric, SampleString},
+    rng, Rng,
 };
 use raphtory::prelude::*;
 
 fn random_string(n: usize) -> String {
-    Alphanumeric.sample_string(&mut thread_rng(), n)
+    Alphanumeric.sample_string(&mut rng(), n)
 }
 
 pub fn graph(c: &mut Criterion) {
@@ -17,13 +17,13 @@ pub fn graph(c: &mut Criterion) {
     });
 
     id_group.bench_function("numeric string input", |bencher| {
-        let id: u64 = thread_rng().gen();
+        let id: u64 = rng().random();
         let id_str = id.to_string();
         bencher.iter(|| id_str.id())
     });
 
     id_group.bench_function("numeric input", |bencher| {
-        let id: u64 = thread_rng().gen();
+        let id: u64 = rng().random();
         bencher.iter(|| id.id())
     });
 
@@ -33,7 +33,7 @@ pub fn graph(c: &mut Criterion) {
     graph_group.bench_function("string  input", |bencher| {
         let src: String = random_string(16);
         let dst: String = random_string(16);
-        let t: i64 = thread_rng().gen();
+        let t: i64 = rng().random();
         bencher.iter(|| g.add_edge(t, src.clone(), dst.clone(), NO_PROPS, None))
     });
     graph_group.finish();
diff --git a/raphtory-benchmark/benches/index_bench.rs b/raphtory-benchmark/benches/index_bench.rs
index 77fc7fb676..e1534c4bc4 100644
--- a/raphtory-benchmark/benches/index_bench.rs
+++ b/raphtory-benchmark/benches/index_bench.rs
@@ -27,7 +27,6 @@ fn bench_graph_index_load(c: &mut Criterion) {
 
     let mut group = c.benchmark_group("graph_index_load");
     group.sample_size(100);
-
     group.bench_function(BenchmarkId::from_parameter("load_once"), |b| {
         b.iter(|| Graph::decode(black_box(&path)).unwrap());
     });
diff --git a/raphtory-benchmark/benches/search_bench.rs b/raphtory-benchmark/benches/search_bench.rs
index 4212c07469..c877d43e06 100644
--- a/raphtory-benchmark/benches/search_bench.rs
+++ b/raphtory-benchmark/benches/search_bench.rs
@@ -1,9 +1,6 @@
 use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
 use once_cell::sync::Lazy;
-use rand::{
-    seq::{IteratorRandom, SliceRandom},
-    thread_rng, Rng,
-};
+use rand::{prelude::IndexedRandom, rng, seq::IteratorRandom, Rng};
 use raphtory::{
     db::{
         api::{
@@ -55,7 +52,7 @@ fn setup_graph() -> Arc<Graph> {
 }
 
 fn get_random_node_names(graph: &Graph) -> Vec<String> {
-    let mut rng = thread_rng();
+    let mut rng = rng();
     iter::repeat_with(move || graph.nodes().into_iter().choose(&mut rng))
         .filter_map(|opt| opt.map(|n| n.name().to_string()))
         .take(100)
@@ -63,7 +60,7 @@ fn get_random_node_names(graph: &Graph) -> Vec<String> {
 }
 
 fn get_random_edges_by_src_dst_names(graph: &Graph) -> Vec<(String, String)> {
-    let mut rng = thread_rng();
+    let mut rng = rng();
     iter::repeat_with(move || graph.edges().into_iter().choose(&mut rng))
         .filter_map(|opt| opt.map(|e| (e.src().name().to_string(), e.dst().name().to_string())))
         .take(100)
@@ -202,15 +199,16 @@ where
     <M as InternalPropertyFilterFactory>::PropertyBuilder:
         PropertyFilterOps + InternalPropertyFilterBuilder<Marker = M, Filter = PropertyFilter<M>>,
 {
-    let mut rng = thread_rng();
+    let mut rng = rng();
 
     match prop_value.dtype() {
         PropType::Str => {
             if let Some(full_str) = prop_value.into_str() {
                 let tokens: Vec<&str> = full_str.split_whitespace().collect();
-                if tokens.len() > 1 && rng.gen_bool(0.3) {
-                    let start = rng.gen_range(0..tokens.len());
-                    let end = rng.gen_range(start..tokens.len());
+                if tokens.len() > 1 && rng.random_bool(0.3) {
+                    // 30% chance to use a random substring
+                    let start = rng.random_range(0..tokens.len());
+                    let end = rng.random_range(start..tokens.len());
                     let sub_str = tokens[start..=end].join(" ");
 
                     match filter_op {
@@ -290,7 +288,7 @@ where
 
 // Get list of properties from multiple random nodes for IN, NOT_IN filters
 fn get_node_property_samples(graph: &Graph, prop_id: &usize, is_const: bool) -> Vec<Prop> {
-    let mut rng = thread_rng();
+    let mut rng = rng();
     let node_names = get_random_node_names(graph);
     let mut samples = Vec::new();
 
@@ -306,7 +304,7 @@ fn get_node_property_samples(graph: &Graph, prop_id: &usize, is_const: bool) ->
                 samples.push(prop_value);
             }
 
-            if samples.len() >= rng.gen_range(3..=5) {
+            if samples.len() >= rng.random_range(3..=5) {
                 break;
             }
         }
@@ -323,7 +321,7 @@ fn pick_node_property_filter(
     is_const: bool,
     filter_op: FilterOperator,
 ) -> Option<PropertyFilter<NodeFilter>> {
-    let mut rng = thread_rng();
+    let mut rng = rng();
     if let Some((prop_name, prop_id)) = props.choose(&mut rng) {
         let prop_value = if is_const {
             node.get_metadata(*prop_id)
@@ -346,7 +344,7 @@ fn get_random_node_property_filters(
     graph: &Graph,
     filter_op: FilterOperator,
 ) -> Vec<PropertyFilter<NodeFilter>> {
-    let mut rng = thread_rng();
+    let mut rng = rng();
     let node_names = get_random_node_names(graph);
 
     let mut filters = Vec::new();
@@ -371,7 +369,7 @@ fn get_random_node_property_filters(
             // Fallback to other property list if one is empty i.e., if const properties are empty
             // fallback to temporal properties and vice versa. This ensures, we always have as many
             // property filters as there are nodes.
-            let choice = rng.gen_bool(0.5);
+            let choice = rng.random_bool(0.5);
             if choice {
                 chosen_filter = pick_node_property_filter(graph, &node, &metadata, true, filter_op);
                 if chosen_filter.is_none() {
@@ -399,7 +397,7 @@ fn get_random_node_property_filters(
 
 // Get list of properties from multiple random edges for IN, NOT_IN filters
 fn get_edge_property_samples(graph: &Graph, prop_id: &usize, is_const: bool) -> Vec<Prop> {
-    let mut rng = thread_rng();
+    let mut rng = rng();
     let edges = get_random_edges_by_src_dst_names(graph);
     let mut samples = Vec::new();
 
@@ -415,7 +413,7 @@ fn get_edge_property_samples(graph: &Graph, prop_id: &usize, is_const: bool) ->
                 samples.push(prop_value);
             }
 
-            if samples.len() >= rng.gen_range(3..=5) {
+            if samples.len() >= rng.random_range(3..=5) {
                 break;
             }
         }
@@ -432,7 +430,7 @@ fn pick_edge_property_filter(
     is_const: bool,
     filter_op: FilterOperator,
 ) -> Option<PropertyFilter<EdgeFilter>> {
-    let mut rng = thread_rng();
+    let mut rng = rng();
 
     if let Some((prop_name, prop_id)) = props.choose(&mut rng) {
         let prop_value = if is_const {
@@ -456,7 +454,7 @@ fn get_random_edge_property_filters(
     graph: &Graph,
     filter_op: FilterOperator,
 ) -> Vec<PropertyFilter<EdgeFilter>> {
-    let mut rng = thread_rng();
+    let mut rng = rng();
     let edges = get_random_edges_by_src_dst_names(graph);
 
     let mut filters = Vec::new();
@@ -481,7 +479,7 @@ fn get_random_edge_property_filters(
             // Fallback to other property list if one is empty i.e., if const properties are empty
             // fallback to temporal properties and vice versa. This ensures, we always have as many
             // property filters as there are edges.
-            let choice = rng.gen_bool(0.5);
+            let choice = rng.random_bool(0.5);
             if choice {
                 chosen_filter = pick_edge_property_filter(graph, &edge, &metadata, true, filter_op);
                 if chosen_filter.is_none() {
@@ -683,7 +681,7 @@ fn bench_search_nodes_by_name(c: &mut Criterion) {
 
 fn bench_search_nodes_by_node_type(c: &mut Criterion) {
     let graph = setup_graph();
-    let mut rng = thread_rng();
+    let mut rng = rng();
     let node_types = get_node_types(&graph);
     let sample_inputs: Vec<_> = (0..100)
         .map(|_| node_types.choose(&mut rng).unwrap().clone())
@@ -730,7 +728,7 @@ fn bench_search_nodes_by_composite_property_filter_and(c: &mut Criterion) {
     let graph = setup_graph();
     let binding = get_random_node_property_filters(&graph, Eq);
     let property_filters = binding.iter().cloned();
-    let mut rng = thread_rng();
+    let mut rng = rng();
 
     c.bench_function("bench_search_nodes_by_composite_property_filter_and", |b| {
         b.iter_batched(
@@ -751,7 +749,7 @@ fn bench_search_nodes_by_composite_property_filter_or(c: &mut Criterion) {
     let graph = setup_graph();
     let binding = get_random_node_property_filters(&graph, Eq);
     let property_filters = binding.iter().cloned();
-    let mut rng = thread_rng();
+    let mut rng = rng();
 
     c.bench_function("bench_search_nodes_by_composite_property_filter_or", |b| {
         b.iter_batched(
@@ -822,7 +820,7 @@ fn bench_search_edges_by_composite_property_filter_and(c: &mut Criterion) {
     let graph = setup_graph();
     let binding = get_random_edge_property_filters(&graph, Eq);
     let property_filters = binding.iter().cloned();
-    let mut rng = thread_rng();
+    let mut rng = rng();
 
     c.bench_function("bench_search_edges_by_composite_property_filter_and", |b| {
         b.iter_batched(
@@ -843,7 +841,7 @@ fn bench_search_edges_by_composite_property_filter_or(c: &mut Criterion) {
     let graph = setup_graph();
     let binding = get_random_edge_property_filters(&graph, Eq);
     let property_filters = binding.iter().cloned();
-    let mut rng = thread_rng();
+    let mut rng = rng();
 
     c.bench_function("bench_search_edges_by_composite_property_filter_or", |b| {
         b.iter_batched(
diff --git a/raphtory-benchmark/benches/tgraph_benchmarks.rs b/raphtory-benchmark/benches/tgraph_benchmarks.rs
index 2595e88443..b2af702edc 100644
--- a/raphtory-benchmark/benches/tgraph_benchmarks.rs
+++ b/raphtory-benchmark/benches/tgraph_benchmarks.rs
@@ -1,5 +1,5 @@
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
-use rand::{distributions::Uniform, Rng};
+use rand::{distr::Uniform, Rng};
 use raphtory::core::entities::nodes::structure::adjset::AdjSet;
 use sorted_vector_map::SortedVectorSet;
 use std::collections::BTreeSet;
@@ -9,8 +9,8 @@ fn btree_set_u64(c: &mut Criterion) {
     for size in [10, 100, 300, 500, 1000].iter() {
         group.throughput(Throughput::Elements(*size as u64));
 
-        let mut rng = rand::thread_rng();
-        let range = Uniform::new(u64::MIN, u64::MAX);
+        let mut rng = rand::rng();
+        let range = Uniform::new(u64::MIN, u64::MAX).unwrap();
         let init_vals: Vec<u64> = (&mut rng).sample_iter(&range).take(*size).collect();
 
         group.bench_with_input(
@@ -49,8 +49,9 @@ fn bm_tadjset(c: &mut Criterion) {
     for size in [10, 100, 1000, 10_000, 100_000, 1_000_000].iter() {
         group.throughput(Throughput::Elements(*size as u64));
 
-        let mut rng = rand::thread_rng();
-        let range = Uniform::new(0, size * 10);
+        let mut rng = rand::rng();
+        let range = Uniform::new(0, size * 10).unwrap();
+
         let init_srcs: Vec<usize> = (&mut rng)
             .sample_iter(&range)
             .take(*size as usize)
@@ -59,7 +60,7 @@ fn bm_tadjset(c: &mut Criterion) {
             .sample_iter(&range)
             .take(*size as usize)
             .collect();
-        let t_range = Uniform::new(1646838523i64, 1678374523);
+        let t_range = Uniform::new(1646838523i64, 1678374523).unwrap();
         let init_time: Vec<i64> = (&mut rng)
             .sample_iter(&t_range)
             .take(*size as usize)
diff --git a/raphtory-benchmark/src/common/mod.rs b/raphtory-benchmark/src/common/mod.rs
index 539135265a..2745efabbb 100644
--- a/raphtory-benchmark/src/common/mod.rs
+++ b/raphtory-benchmark/src/common/mod.rs
@@ -5,22 +5,22 @@ pub mod vectors;
 use criterion::{
     black_box, measurement::WallTime, BatchSize, Bencher, BenchmarkGroup, BenchmarkId, Criterion,
 };
-use rand::{distributions::Uniform, seq::*, Rng, SeedableRng};
+use rand::{distr::Uniform, seq::*, Rng, SeedableRng};
 use raphtory::{db::api::view::StaticGraphViewOps, prelude::*};
 use raphtory_api::core::{storage::timeindex::AsTime, utils::logging::global_info_logger};
-use std::collections::HashSet;
+use std::{collections::HashSet, iter};
 use tempfile::TempDir;
 use tracing::info;
 
 fn make_index_gen() -> Box<dyn Iterator<Item = u64>> {
-    let rng = rand::thread_rng();
-    let range = Uniform::new(u64::MIN, u64::MAX);
+    let rng = rand::rng();
+    let range = Uniform::new(u64::MIN, u64::MAX).unwrap();
     Box::new(rng.sample_iter(range))
 }
 
 fn make_time_gen() -> Box<dyn Iterator<Item = i64>> {
-    let rng = rand::thread_rng();
-    let range = Uniform::new(i64::MIN, i64::MAX);
+    let rng = rand::rng();
+    let range = Uniform::new(i64::MIN, i64::MAX).unwrap();
     Box::new(rng.sample_iter(range))
 }
 
@@ -77,7 +77,7 @@ pub fn run_ingestion_benchmarks<F>(
         |b: &mut Bencher| {
             b.iter_batched_ref(
                 || (make_graph(), time_sample()),
-                |(g, t): &mut (Graph, i64)| g.add_node(*t, 0, NO_PROPS, None),
+                |(g, t): &mut (Graph, i64)| g.add_node(*t, 0, NO_PROPS, None, None),
                 BatchSize::SmallInput,
             )
         },
@@ -89,7 +89,7 @@ pub fn run_ingestion_benchmarks<F>(
         |b: &mut Bencher| {
             b.iter_batched_ref(
                 || (make_graph(), index_sample()),
-                |(g, v): &mut (Graph, u64)| g.add_node(0, *v, NO_PROPS, None),
+                |(g, v): &mut (Graph, u64)| g.add_node(0, *v, NO_PROPS, None, None),
                 BatchSize::SmallInput,
             )
         },
@@ -300,7 +300,7 @@ pub fn run_analysis_benchmarks<F, G>(
     });
 
     bench(group, "has_edge_existing", parameter, |b: &mut Bencher| {
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         let (src, dst) = edges
             .iter()
             .choose(&mut rng)
@@ -313,7 +313,7 @@ pub fn run_analysis_benchmarks<F, G>(
         "has_edge_nonexisting",
         parameter,
         |b: &mut Bencher| {
-            let mut rng = rand::thread_rng();
+            let mut rng = rand::rng();
             let edge = loop {
                 let edge: (&GID, &GID) = (
                     nodes.iter().choose(&mut rng).expect("has_edge_nonexisting: non-empty graph (graph().nodes().id().iter() is empty)"),
@@ -328,7 +328,7 @@ pub fn run_analysis_benchmarks<F, G>(
     );
 
     bench(group, "active edge", parameter, |b: &mut Bencher| {
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         let (edge, active_t) = edges_t
             .choose(&mut rng)
             .and_then(|(src, dst, t)| graph.edge(src, dst).map(|e| (e, t.t())))
@@ -344,7 +344,7 @@ pub fn run_analysis_benchmarks<F, G>(
     });
 
     bench(group, "edge has layer", parameter, |b: &mut Bencher| {
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         let edge = edges
             .iter()
             .choose(&mut rng)
@@ -364,7 +364,7 @@ pub fn run_analysis_benchmarks<F, G>(
     });
 
     bench(group, "has_node_existing", parameter, |b: &mut Bencher| {
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         let v = nodes
             .iter()
             .choose(&mut rng)
@@ -377,9 +377,9 @@ pub fn run_analysis_benchmarks<F, G>(
         "has_node_nonexisting",
         parameter,
         |b: &mut Bencher| {
-            let mut rng = rand::thread_rng();
+            let mut rng = rand::rng();
             let v: u64 = loop {
-                let v: u64 = rng.gen();
+                let v: u64 = rng.random();
                 if !nodes.contains(&GID::U64(v)) {
                     break v;
                 }
@@ -513,12 +513,12 @@ pub fn run_graph_ops_benches(
 
     // subgraph
     let mut rng = rand::rngs::StdRng::seed_from_u64(73);
-    let nodes = graph
+    let nodes = (&&graph)
         .nodes()
         .into_iter()
-        .choose_multiple(&mut rng, graph.count_nodes() / 10)
+        .choose_multiple(&mut rng, 1.max(graph.count_nodes() / 10))
         .into_iter()
-        .map(|n| n.id())
+        .flat_map(|n| iter::once(n.id()).chain(n.out_neighbours().id().next())) // at least one edge per node
         .collect::<Vec<_>>();
     let subgraph = graph.subgraph(nodes);
     let group_name = format!("{graph_name}_subgraph_10pc");
diff --git a/raphtory-benchmark/src/common/vectors.rs b/raphtory-benchmark/src/common/vectors.rs
index f699fec569..75ca800aba 100644
--- a/raphtory-benchmark/src/common/vectors.rs
+++ b/raphtory-benchmark/src/common/vectors.rs
@@ -17,7 +17,7 @@ pub fn gen_embedding_for_bench(text: &str) -> Embedding {
     let hash = hasher.finish();
 
     let mut rng: StdRng = SeedableRng::seed_from_u64(hash);
-    (0..1536).map(|_| rng.gen()).collect()
+    (0..1536).map(|_| rng.random()).collect()
 }
 
 async fn embedding_model(texts: Vec<String>) -> EmbeddingResult<Vec<Embedding>> {
@@ -30,7 +30,7 @@ async fn embedding_model(texts: Vec<String>) -> EmbeddingResult<Vec<Embedding>>
 pub fn create_graph_for_vector_bench(size: usize) -> Graph {
     let graph = Graph::new();
     for id in 0..size {
-        graph.add_node(0, id as u64, NO_PROPS, None).unwrap();
+        graph.add_node(0, id as u64, NO_PROPS, None, None).unwrap();
     }
     graph
 }
diff --git a/raphtory-benchmark/src/graph_gen/raph_social.rs b/raphtory-benchmark/src/graph_gen/raph_social.rs
index cd75f1277e..7cb4693ce5 100644
--- a/raphtory-benchmark/src/graph_gen/raph_social.rs
+++ b/raphtory-benchmark/src/graph_gen/raph_social.rs
@@ -15,7 +15,7 @@ use fake::{
     },
     Fake,
 };
-use rand::{prelude::SliceRandom, thread_rng, Rng};
+use rand::{rng, seq::IndexedRandom, Rng};
 use raphtory::prelude::*;
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 use std::{collections::HashMap, error::Error, fmt::Debug};
@@ -89,7 +89,7 @@ pub struct CommentPost {
 }
 
 fn gen_timestamp(rng: &mut impl Rng) -> i64 {
-    rng.gen_range(946684800000..1609459200000) // Random timestamp from 2000 to 2020
+    rng.random_range(946684800000..1609459200000) // Random timestamp from 2000 to 2020
 }
 
 pub fn generate_data_write_to_csv(
@@ -101,7 +101,7 @@ pub fn generate_data_write_to_csv(
 ) -> Result<(), Box<dyn Error>> {
     fs::create_dir_all(output_dir)?;
 
-    let mut rng = thread_rng();
+    let mut rng = rng();
 
     // Create writers for each file
     let mut people_writer = Writer::from_path(format!("{}/people.csv", output_dir))?;
@@ -118,7 +118,7 @@ pub fn generate_data_write_to_csv(
             id: format!("person_{}", i),
             first_name: FirstName().fake(),
             last_name: LastName().fake(),
-            gender: if rng.gen_bool(0.5) {
+            gender: if rng.random_bool(0.5) {
                 "male".to_string()
             } else {
                 "female".to_string()
@@ -141,14 +141,14 @@ pub fn generate_data_write_to_csv(
 
     // Person-Forum Relationships
     for i in 1..=num_people {
-        let membership_count = rng.gen_range(1..=3);
+        let membership_count = rng.random_range(1..=3);
         for _ in 0..membership_count {
             person_forum_writer.serialize(PersonForum {
                 person_id: format!("person_{}", i),
-                forum_id: format!("forum_{}", rng.gen_range(1..=num_forums)),
-                is_moderator: rng.gen_bool(0.1),
+                forum_id: format!("forum_{}", rng.random_range(1..=num_forums)),
+                is_moderator: rng.random_bool(0.1),
                 join_date: gen_timestamp(&mut rng),
-                activity_score: rng.gen_range(0.0..100.0),
+                activity_score: rng.random_range(0.0..100.0),
             })?;
         }
     }
@@ -159,7 +159,7 @@ pub fn generate_data_write_to_csv(
         let creation_date = gen_timestamp(&mut rng);
         posts_writer.serialize(Post {
             id: format!("post_{}", i),
-            creator_id: format!("person_{}", rng.gen_range(1..=num_people)),
+            creator_id: format!("person_{}", rng.random_range(1..=num_people)),
             creation_date,
             location_ip: IP().fake(),
             browser_used: ["Chrome", "Firefox", "Safari", "Edge"]
@@ -167,15 +167,15 @@ pub fn generate_data_write_to_csv(
                 .unwrap()
                 .to_string(),
             content: Sentence(5..15).fake(),
-            length: rng.gen_range(20..200),
+            length: rng.random_range(20..200),
         })?;
         post_forum_writer.serialize(PostForum {
             post_id: format!("post_{}", i),
-            forum_id: format!("forum_{}", rng.gen_range(1..=num_forums)),
+            forum_id: format!("forum_{}", rng.random_range(1..=num_forums)),
             creation_date, // Use post's creation date
-            is_featured: rng.gen_bool(0.2),
-            likes_count: rng.gen_range(0..500),
-            comments_count: rng.gen_range(0..200),
+            is_featured: rng.random_bool(0.2),
+            likes_count: rng.random_range(0..500),
+            comments_count: rng.random_range(0..200),
         })?;
     }
     posts_writer.flush()?;
@@ -186,7 +186,7 @@ pub fn generate_data_write_to_csv(
         let creation_date = gen_timestamp(&mut rng);
         comments_writer.serialize(Comment {
             id: format!("comment_{}", i),
-            creator_id: format!("person_{}", rng.gen_range(1..=num_people)),
+            creator_id: format!("person_{}", rng.random_range(1..=num_people)),
             creation_date,
             location_ip: IP().fake(),
             browser_used: ["Chrome", "Firefox", "Safari", "Edge"]
@@ -194,15 +194,15 @@ pub fn generate_data_write_to_csv(
                 .unwrap()
                 .to_string(),
             content: Sentence(5..15).fake(),
-            length: rng.gen_range(50..500),
+            length: rng.random_range(50..500),
         })?;
         comment_post_writer.serialize(CommentPost {
             comment_id: format!("comment_{}", i),
-            post_id: format!("post_{}", rng.gen_range(1..=num_posts)),
+            post_id: format!("post_{}", rng.random_range(1..=num_posts)),
             creation_date, // Use comment's creation date
-            is_edited: rng.gen_bool(0.1),
-            upvotes: rng.gen_range(0..200),
-            reply_count: rng.gen_range(0..20),
+            is_edited: rng.random_bool(0.1),
+            upvotes: rng.random_range(0..200),
+            reply_count: rng.random_range(0..20),
         })?;
     }
     comments_writer.flush()?;
@@ -278,6 +278,7 @@ pub fn load_graph_save(data_dir: &str, output_dir: &str) -> Result<Graph, Box<dy
             person.id.clone(),
             NO_PROPS,
             Some("person"),
+            None,
         )
         .expect("Failed to add node")
         .add_metadata([
@@ -295,6 +296,7 @@ pub fn load_graph_save(data_dir: &str, output_dir: &str) -> Result<Graph, Box<dy
             forum.id.clone(),
             NO_PROPS,
             Some("forum"),
+            None,
         )
         .expect("Failed to add node")
         .add_metadata([("title", Prop::Str(ArcStr::from(forum.title)))])
@@ -312,6 +314,7 @@ pub fn load_graph_save(data_dir: &str, output_dir: &str) -> Result<Graph, Box<dy
                 ("browser_used", Prop::Str(ArcStr::from(post.browser_used))),
             ],
             Some("post"),
+            None,
         )
         .expect("Failed to add node")
         .add_metadata([("creator_id", Prop::Str(ArcStr::from(post.creator_id)))])
@@ -332,6 +335,7 @@ pub fn load_graph_save(data_dir: &str, output_dir: &str) -> Result<Graph, Box<dy
                 ),
             ],
             Some("comment"),
+            None,
         )
         .expect("Failed to add node")
         .add_metadata([("creator_id", Prop::Str(ArcStr::from(comment.creator_id)))])
@@ -394,7 +398,7 @@ pub fn generate_graph(
     num_posts: usize,
     num_comments: usize,
 ) -> Graph {
-    let mut rng = thread_rng();
+    let mut rng = rng();
     let graph = Graph::new();
 
     // People
@@ -408,6 +412,7 @@ pub fn generate_graph(
                 person_id.clone(),
                 NO_PROPS,
                 Some("person"),
+                None,
             )
             .expect("Failed to add person node")
             .add_metadata([
@@ -421,7 +426,7 @@ pub fn generate_graph(
                 ),
                 (
                     "gender",
-                    Prop::Str(ArcStr::from(if rng.gen_bool(0.5) {
+                    Prop::Str(ArcStr::from(if rng.random_bool(0.5) {
                         "male"
                     } else {
                         "female"
@@ -443,6 +448,7 @@ pub fn generate_graph(
                 forum_id.clone(),
                 NO_PROPS,
                 Some("forum"),
+                None,
             )
             .expect("Failed to add forum node")
             .add_metadata([(
@@ -455,17 +461,17 @@ pub fn generate_graph(
     // Person Forum
     for i in 1..=num_people {
         let person_id = format!("person_{}", i);
-        let membership_count = rng.gen_range(1..=3);
+        let membership_count = rng.random_range(1..=3);
         for _ in 0..membership_count {
-            let forum_id = format!("forum_{}", rng.gen_range(1..=num_forums));
+            let forum_id = format!("forum_{}", rng.random_range(1..=num_forums));
             graph
                 .add_edge(
                     DateTime::from_timestamp(gen_timestamp(&mut rng), 0).unwrap(),
                     person_id.clone(),
                     forum_id.clone(),
                     [
-                        ("activity_score", Prop::F64(rng.gen_range(0.0..100.0))),
-                        ("is_moderator", Prop::Bool(rng.gen_bool(0.1))),
+                        ("activity_score", Prop::F64(rng.random_range(0.0..100.0))),
+                        ("is_moderator", Prop::Bool(rng.random_bool(0.1))),
                     ],
                     None,
                 )
@@ -476,7 +482,7 @@ pub fn generate_graph(
     // Posts, Post Forum
     for i in 1..=num_posts {
         let post_id = format!("post_{}", i);
-        let creator_id = format!("person_{}", rng.gen_range(1..=num_people));
+        let creator_id = format!("person_{}", rng.random_range(1..=num_people));
         let creation_date = gen_timestamp(&mut rng);
 
         graph
@@ -488,7 +494,7 @@ pub fn generate_graph(
                         "content",
                         Prop::Str(ArcStr::from(Sentence(5..15).fake::<String>())),
                     ),
-                    ("length", Prop::U64(rng.gen_range(20..200))),
+                    ("length", Prop::U64(rng.random_range(20..200))),
                     (
                         "location_ip",
                         Prop::Str(ArcStr::from(IP().fake::<String>())),
@@ -504,21 +510,22 @@ pub fn generate_graph(
                     ),
                 ],
                 Some("post"),
+                None,
             )
             .expect("Failed to add post node")
             .add_metadata([("creator_id", Prop::Str(ArcStr::from(creator_id.clone())))])
             .expect("Failed to add post properties");
 
-        let forum_id = format!("forum_{}", rng.gen_range(1..=num_forums));
+        let forum_id = format!("forum_{}", rng.random_range(1..=num_forums));
         graph
             .add_edge(
                 DateTime::from_timestamp(creation_date, 0).unwrap(),
                 post_id.clone(),
                 forum_id.clone(),
                 [
-                    ("is_featured", Prop::Bool(rng.gen_bool(0.2))),
-                    ("likes_count", Prop::U64(rng.gen_range(0..500))),
-                    ("comments_count", Prop::U64(rng.gen_range(0..200))),
+                    ("is_featured", Prop::Bool(rng.random_bool(0.2))),
+                    ("likes_count", Prop::U64(rng.random_range(0..500))),
+                    ("comments_count", Prop::U64(rng.random_range(0..200))),
                 ],
                 None,
             )
@@ -528,7 +535,7 @@ pub fn generate_graph(
     // Comments, Comment Forum
     for i in 1..=num_comments {
         let comment_id = format!("comment_{}", i);
-        let creator_id = format!("person_{}", rng.gen_range(1..=num_people));
+        let creator_id = format!("person_{}", rng.random_range(1..=num_people));
         let creation_date = gen_timestamp(&mut rng);
 
         graph
@@ -540,7 +547,7 @@ pub fn generate_graph(
                         "content",
                         Prop::Str(ArcStr::from(Sentence(5..15).fake::<String>())),
                     ),
-                    ("length", Prop::U64(rng.gen_range(50..500))),
+                    ("length", Prop::U64(rng.random_range(50..500))),
                     (
                         "location_ip",
                         Prop::Str(ArcStr::from(IP().fake::<String>())),
@@ -556,21 +563,22 @@ pub fn generate_graph(
                     ),
                 ],
                 Some("comment"),
+                None,
             )
             .expect("Failed to add comment node")
             .add_metadata([("creator_id", Prop::Str(ArcStr::from(creator_id.clone())))])
             .expect("Failed to add comment properties");
 
-        let post_id = format!("post_{}", rng.gen_range(1..=num_posts));
+        let post_id = format!("post_{}", rng.random_range(1..=num_posts));
         graph
             .add_edge(
                 DateTime::from_timestamp(creation_date, 0).unwrap(),
                 comment_id.clone(),
                 post_id.clone(),
                 [
-                    ("is_edited", Prop::Bool(rng.gen_bool(0.1))),
-                    ("upvotes", Prop::U64(rng.gen_range(0..200))),
-                    ("reply_count", Prop::U64(rng.gen_range(0..20))),
+                    ("is_edited", Prop::Bool(rng.random_bool(0.1))),
+                    ("upvotes", Prop::U64(rng.random_range(0..200))),
+                    ("reply_count", Prop::U64(rng.random_range(0..20))),
                 ],
                 None,
             )
diff --git a/raphtory-core/Cargo.toml b/raphtory-core/Cargo.toml
index 2b888a58c8..7e63a1bae3 100644
--- a/raphtory-core/Cargo.toml
+++ b/raphtory-core/Cargo.toml
@@ -14,7 +14,8 @@ edition.workspace = true
 
 [dependencies]
 raphtory-api = { workspace = true }
-dashmap = { workspace = true }
+dashmap = { workspace = true, features = ["raw-api"] }
+hashbrown = { workspace = true }
 either = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 rustc-hash = { workspace = true }
@@ -28,6 +29,10 @@ parking_lot = { workspace = true }
 itertools = { workspace = true }
 once_cell = { workspace = true }
 ouroboros = { workspace = true }
+arrow-array = { workspace = true }
+arrow-buffer = { workspace = true }
+arrow-data = { workspace = true }
+arrow-schema = { workspace = true }
 regex = { workspace = true }
 pyo3 = { workspace = true, optional = true }
 
@@ -35,5 +40,4 @@ pyo3 = { workspace = true, optional = true }
 proptest = { workspace = true }
 
 [features]
-arrow = ["raphtory-api/arrow"]
 python = ["dep:pyo3", "raphtory-api/python"]
diff --git a/raphtory-core/src/entities/edges/edge_store.rs b/raphtory-core/src/entities/edges/edge_store.rs
deleted file mode 100644
index d05a920f47..0000000000
--- a/raphtory-core/src/entities/edges/edge_store.rs
+++ /dev/null
@@ -1,178 +0,0 @@
-use crate::{
-    entities::{
-        properties::props::{MetadataError, Props, TPropError},
-        EID, VID,
-    },
-    storage::{
-        raw_edges::EdgeShard,
-        timeindex::{EventTime, TimeIndex},
-    },
-    utils::iter::GenLockedIter,
-};
-use itertools::Itertools;
-use raphtory_api::core::entities::{edges::edge_ref::EdgeRef, properties::prop::Prop};
-use serde::{Deserialize, Serialize};
-use std::{
-    fmt::{Debug, Formatter},
-    ops::Deref,
-};
-
-#[derive(Clone, Serialize, Deserialize, Debug, Default, PartialEq)]
-pub struct EdgeStore {
-    pub eid: EID,
-    pub src: VID,
-    pub dst: VID,
-}
-
-pub trait EdgeDataLike<'a> {
-    fn temporal_prop_ids(self) -> impl Iterator<Item = usize> + 'a;
-    fn metadata_ids(self) -> impl Iterator<Item = usize> + 'a;
-}
-
-impl<'a, T: Deref<Target = EdgeLayer> + 'a> EdgeDataLike<'a> for T {
-    fn temporal_prop_ids(self) -> impl Iterator<Item = usize> + 'a {
-        GenLockedIter::from(self, |layer| {
-            Box::new(
-                layer
-                    .props()
-                    .into_iter()
-                    .flat_map(|props| props.temporal_prop_ids()),
-            )
-        })
-    }
-
-    fn metadata_ids(self) -> impl Iterator<Item = usize> + 'a {
-        GenLockedIter::from(self, |layer| {
-            Box::new(
-                layer
-                    .props()
-                    .into_iter()
-                    .flat_map(|props| props.metadata_ids()),
-            )
-        })
-    }
-}
-
-#[derive(Serialize, Deserialize, Debug, Default, PartialEq)]
-pub struct EdgeLayer {
-    props: Option<Props>, // memory optimisation: only allocate props if needed
-}
-
-impl EdgeLayer {
-    pub fn props(&self) -> Option<&Props> {
-        self.props.as_ref()
-    }
-
-    pub fn into_props(self) -> Option<Props> {
-        self.props
-    }
-
-    pub fn add_prop(&mut self, t: EventTime, prop_id: usize, prop: Prop) -> Result<(), TPropError> {
-        let props = self.props.get_or_insert_with(Props::new);
-        props.add_prop(t, prop_id, prop)
-    }
-
-    pub fn add_metadata(&mut self, prop_id: usize, prop: Prop) -> Result<(), MetadataError> {
-        let props = self.props.get_or_insert_with(Props::new);
-        props.add_metadata(prop_id, prop)
-    }
-
-    pub fn update_metadata(&mut self, prop_id: usize, prop: Prop) -> Result<(), MetadataError> {
-        let props = self.props.get_or_insert_with(Props::new);
-        props.update_metadata(prop_id, prop)
-    }
-}
-
-impl EdgeStore {
-    pub fn new(src: VID, dst: VID) -> Self {
-        Self {
-            eid: 0.into(),
-            src,
-            dst,
-        }
-    }
-
-    pub fn initialised(&self) -> bool {
-        self.eid != EID::default()
-    }
-
-    pub fn as_edge_ref(&self) -> EdgeRef {
-        EdgeRef::new_outgoing(self.eid, self.src, self.dst)
-    }
-}
-
-#[derive(Clone, Copy)]
-pub struct MemEdge<'a> {
-    edges: &'a EdgeShard,
-    offset: usize,
-}
-
-impl<'a> Debug for MemEdge<'a> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("Edge")
-            .field("src", &self.src())
-            .field("dst", &self.dst())
-            .field("eid", &self.eid())
-            .field(
-                "props",
-                &(0..self.internal_num_layers())
-                    .map(|i| (i, self.props(i)))
-                    .collect_vec(),
-            )
-            .finish()
-    }
-}
-
-impl<'a> MemEdge<'a> {
-    pub fn new(edges: &'a EdgeShard, offset: usize) -> Self {
-        MemEdge { edges, offset }
-    }
-
-    pub fn src(&self) -> VID {
-        self.edge_store().src
-    }
-
-    pub fn dst(&self) -> VID {
-        self.edge_store().dst
-    }
-    pub fn edge_store(&self) -> &'a EdgeStore {
-        self.edges.edge_store(self.offset)
-    }
-
-    #[inline]
-    pub fn props(self, layer_id: usize) -> Option<&'a Props> {
-        self.edges
-            .props(self.offset, layer_id)
-            .and_then(|el| el.props())
-    }
-
-    pub fn eid(self) -> EID {
-        self.edge_store().eid
-    }
-
-    pub fn as_edge_ref(&self) -> EdgeRef {
-        EdgeRef::new_outgoing(self.eid(), self.src(), self.dst())
-    }
-
-    pub fn internal_num_layers(self) -> usize {
-        self.edges.internal_num_layers()
-    }
-
-    pub fn get_additions(self, layer_id: usize) -> Option<&'a TimeIndex<EventTime>> {
-        self.edges.additions(self.offset, layer_id)
-    }
-
-    pub fn get_deletions(self, layer_id: usize) -> Option<&'a TimeIndex<EventTime>> {
-        self.edges.deletions(self.offset, layer_id)
-    }
-
-    pub fn has_layer_inner(self, layer_id: usize) -> bool {
-        self.get_additions(layer_id)
-            .filter(|t_index| !t_index.is_empty())
-            .is_some()
-            || self
-                .get_deletions(layer_id)
-                .filter(|t_index| !t_index.is_empty())
-                .is_some()
-    }
-}
diff --git a/raphtory-core/src/entities/edges/mod.rs b/raphtory-core/src/entities/edges/mod.rs
deleted file mode 100644
index d1f7224234..0000000000
--- a/raphtory-core/src/entities/edges/mod.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-pub mod edge_store;
-
-pub use raphtory_api::core::entities::edges::*;
diff --git a/raphtory-core/src/entities/graph/logical_to_physical.rs b/raphtory-core/src/entities/graph/logical_to_physical.rs
index cf4d1afe93..8b13789179 100644
--- a/raphtory-core/src/entities/graph/logical_to_physical.rs
+++ b/raphtory-core/src/entities/graph/logical_to_physical.rs
@@ -1,232 +1 @@
-use crate::{
-    entities::nodes::node_store::NodeStore,
-    storage::{NodeSlot, UninitialisedEntry},
-};
-use dashmap::mapref::entry::Entry;
-use either::Either;
-use once_cell::sync::OnceCell;
-use raphtory_api::core::{
-    entities::{GidRef, GidType, VID},
-    storage::{dict_mapper::MaybeNew, FxDashMap},
-};
-use serde::{Deserialize, Deserializer, Serialize};
-use std::hash::Hash;
-use thiserror::Error;
 
-#[derive(Debug, Deserialize, Serialize)]
-enum Map {
-    U64(FxDashMap<u64, VID>),
-    Str(FxDashMap<String, VID>),
-}
-
-#[derive(Error, Debug)]
-pub enum InvalidNodeId {
-    #[error("Node id {0} does not have the correct type, expected String")]
-    InvalidNodeIdU64(u64),
-    #[error("Node id {0} does not have the correct type, expected Numeric")]
-    InvalidNodeIdStr(String),
-}
-
-impl Map {
-    fn as_u64(&self) -> Option<&FxDashMap<u64, VID>> {
-        match self {
-            Map::U64(map) => Some(map),
-            _ => None,
-        }
-    }
-
-    fn as_str(&self) -> Option<&FxDashMap<String, VID>> {
-        match self {
-            Map::Str(map) => Some(map),
-            _ => None,
-        }
-    }
-}
-
-impl Default for Map {
-    fn default() -> Self {
-        Map::U64(FxDashMap::default())
-    }
-}
-
-#[derive(Debug, Default)]
-pub struct Mapping {
-    map: OnceCell<Map>,
-}
-
-impl Mapping {
-    pub fn dtype(&self) -> Option<GidType> {
-        self.map.get().map(|map| match map {
-            Map::U64(_) => GidType::U64,
-            Map::Str(_) => GidType::Str,
-        })
-    }
-    pub fn new() -> Self {
-        Mapping {
-            map: OnceCell::new(),
-        }
-    }
-
-    pub fn set(&self, gid: GidRef, vid: VID) -> Result<(), InvalidNodeId> {
-        let map = self.map.get_or_init(|| match gid {
-            GidRef::U64(_) => Map::U64(FxDashMap::default()),
-            GidRef::Str(_) => Map::Str(FxDashMap::default()),
-        });
-        match gid {
-            GidRef::U64(id) => {
-                map.as_u64()
-                    .ok_or(InvalidNodeId::InvalidNodeIdU64(id))?
-                    .insert(id, vid);
-            }
-            GidRef::Str(id) => {
-                let id = id.to_owned();
-                match map.as_str() {
-                    None => return Err(InvalidNodeId::InvalidNodeIdStr(id)),
-                    Some(map) => {
-                        map.insert(id, vid);
-                    }
-                }
-            }
-        }
-        Ok(())
-    }
-
-    pub fn get_or_init(
-        &self,
-        gid: GidRef,
-        next_id: impl FnOnce() -> VID,
-    ) -> Result<MaybeNew<VID>, InvalidNodeId> {
-        let map = self.map.get_or_init(|| match &gid {
-            GidRef::U64(_) => Map::U64(FxDashMap::default()),
-            GidRef::Str(_) => Map::Str(FxDashMap::default()),
-        });
-        let vid = match gid {
-            GidRef::U64(id) => {
-                let map = map.as_u64().ok_or(InvalidNodeId::InvalidNodeIdU64(id))?;
-                match map.entry(id) {
-                    Entry::Occupied(id) => MaybeNew::Existing(*id.get()),
-                    Entry::Vacant(entry) => {
-                        let vid = next_id();
-                        entry.insert(vid);
-                        MaybeNew::New(vid)
-                    }
-                }
-            }
-            GidRef::Str(id) => {
-                let map = map
-                    .as_str()
-                    .ok_or_else(|| InvalidNodeId::InvalidNodeIdStr(id.into()))?;
-                map.get(id)
-                    .map(|vid| MaybeNew::Existing(*vid))
-                    .unwrap_or_else(|| match map.entry(id.to_owned()) {
-                        Entry::Occupied(entry) => MaybeNew::Existing(*entry.get()),
-                        Entry::Vacant(entry) => {
-                            let vid = next_id();
-                            entry.insert(vid);
-                            MaybeNew::New(vid)
-                        }
-                    })
-            }
-        };
-        Ok(vid)
-    }
-
-    pub fn get_or_init_node<'a>(
-        &self,
-        gid: GidRef,
-        f_init: impl FnOnce() -> UninitialisedEntry<'a, NodeStore, NodeSlot>,
-    ) -> Result<MaybeNew<VID>, InvalidNodeId> {
-        let map = self.map.get_or_init(|| match &gid {
-            GidRef::U64(_) => Map::U64(FxDashMap::default()),
-            GidRef::Str(_) => Map::Str(FxDashMap::default()),
-        });
-        match gid {
-            GidRef::U64(id) => map
-                .as_u64()
-                .map(|m| get_or_new(m, id, f_init))
-                .ok_or(InvalidNodeId::InvalidNodeIdU64(id)),
-            GidRef::Str(id) => map
-                .as_str()
-                .map(|m| optim_get_or_insert(m, id, f_init))
-                .ok_or_else(|| InvalidNodeId::InvalidNodeIdStr(id.into())),
-        }
-    }
-
-    #[inline]
-    pub fn get_str(&self, gid: &str) -> Option<VID> {
-        let map = self.map.get()?;
-        map.as_str().and_then(|m| m.get(gid).map(|id| *id))
-    }
-
-    #[inline]
-    pub fn get_u64(&self, gid: u64) -> Option<VID> {
-        let map = self.map.get()?;
-        map.as_u64().and_then(|m| m.get(&gid).map(|id| *id))
-    }
-}
-
-#[inline]
-fn optim_get_or_insert<'a>(
-    m: &FxDashMap<String, VID>,
-    id: &str,
-    f_init: impl FnOnce() -> UninitialisedEntry<'a, NodeStore, NodeSlot>,
-) -> MaybeNew<VID> {
-    m.get(id)
-        .map(|vid| MaybeNew::Existing(*vid))
-        .unwrap_or_else(|| get_or_new(m, id.to_owned(), f_init))
-}
-
-#[inline]
-fn get_or_new<'a, K: Eq + Hash>(
-    m: &FxDashMap<K, VID>,
-    id: K,
-    f_init: impl FnOnce() -> UninitialisedEntry<'a, NodeStore, NodeSlot>,
-) -> MaybeNew<VID> {
-    let entry = match m.entry(id) {
-        Entry::Occupied(entry) => Either::Left(*entry.get()),
-        Entry::Vacant(entry) => {
-            // This keeps the underlying storage shard locked for deferred initialisation but
-            // allows unlocking the map again.
-            let node = f_init();
-            entry.insert(node.value().vid);
-            Either::Right(node)
-        }
-    };
-    match entry {
-        Either::Left(vid) => MaybeNew::Existing(vid),
-        Either::Right(node_entry) => {
-            let vid = node_entry.value().vid;
-            node_entry.init();
-            MaybeNew::New(vid)
-        }
-    }
-}
-
-impl<'de> Deserialize<'de> for Mapping {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        if let Some(map) = Option::<Map>::deserialize(deserializer)? {
-            let once = OnceCell::with_value(map);
-            Ok(Mapping { map: once })
-        } else {
-            Ok(Mapping {
-                map: OnceCell::new(),
-            })
-        }
-    }
-}
-
-impl Serialize for Mapping {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        if let Some(map) = self.map.get() {
-            Some(map).serialize(serializer)
-        } else {
-            serializer.serialize_none()
-        }
-    }
-}
diff --git a/raphtory-core/src/entities/graph/mod.rs b/raphtory-core/src/entities/graph/mod.rs
index fc072dffdb..e16922dcc9 100644
--- a/raphtory-core/src/entities/graph/mod.rs
+++ b/raphtory-core/src/entities/graph/mod.rs
@@ -1,4 +1,3 @@
 pub mod logical_to_physical;
 pub mod tgraph;
-pub mod tgraph_storage;
 pub mod timer;
diff --git a/raphtory-core/src/entities/graph/tgraph.rs b/raphtory-core/src/entities/graph/tgraph.rs
index 8822c164ca..1182d97800 100644
--- a/raphtory-core/src/entities/graph/tgraph.rs
+++ b/raphtory-core/src/entities/graph/tgraph.rs
@@ -1,58 +1,7 @@
-use super::logical_to_physical::{InvalidNodeId, Mapping};
-use crate::{
-    entities::{
-        edges::edge_store::EdgeStore,
-        graph::{
-            tgraph_storage::GraphStorage,
-            timer::{MaxCounter, MinCounter, TimeCounterTrait},
-        },
-        nodes::{node_ref::NodeRef, node_store::NodeStore},
-        properties::graph_meta::GraphMeta,
-        LayerIds, EID, VID,
-    },
-    storage::{
-        raw_edges::EdgeWGuard,
-        timeindex::{AsTime, EventTime},
-        NodeEntry, PairEntryMut,
-    },
-};
-use dashmap::DashSet;
-use either::Either;
-use raphtory_api::core::{
-    entities::{
-        properties::{meta::Meta, prop::Prop},
-        GidRef, Layer, Multiple, MAX_LAYER,
-    },
-    input::input_node::InputNode,
-    storage::{arc_str::ArcStr, dict_mapper::MaybeNew},
-    Direction,
-};
-use rustc_hash::FxHasher;
-use serde::{Deserialize, Serialize};
-use std::{fmt::Debug, hash::BuildHasherDefault, sync::atomic::AtomicUsize};
+use raphtory_api::core::{entities::MAX_LAYER, storage::arc_str::ArcStr};
+use std::fmt::Debug;
 use thiserror::Error;
 
-pub(crate) type FxDashSet<K> = DashSet<K, BuildHasherDefault<FxHasher>>;
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct TemporalGraph {
-    pub storage: GraphStorage,
-    // mapping between logical and physical ids
-    pub logical_to_physical: Mapping,
-    string_pool: FxDashSet<ArcStr>,
-    pub event_counter: AtomicUsize,
-    //earliest time seen in this graph
-    pub earliest_time: MinCounter,
-    //latest time seen in this graph
-    pub latest_time: MaxCounter,
-    // props meta data for nodes (mapping between strings and ids)
-    pub node_meta: Meta,
-    // props meta data for edges (mapping between strings and ids)
-    pub edge_meta: Meta,
-    // graph properties
-    pub graph_meta: GraphMeta,
-}
-
 #[derive(Error, Debug)]
 #[error("Invalid layer: {invalid_layer}. Valid layers: {valid_layers:?}")]
 pub struct InvalidLayer {
@@ -72,278 +21,3 @@ impl InvalidLayer {
         }
     }
 }
-
-impl std::fmt::Display for TemporalGraph {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "Graph(num_nodes={}, num_edges={})",
-            self.storage.nodes_len(),
-            self.storage.edges_len()
-        )
-    }
-}
-
-impl Default for TemporalGraph {
-    fn default() -> Self {
-        Self::new(rayon::current_num_threads())
-    }
-}
-
-impl TemporalGraph {
-    pub fn new(num_locks: usize) -> Self {
-        TemporalGraph {
-            logical_to_physical: Mapping::new(),
-            string_pool: Default::default(),
-            storage: GraphStorage::new(num_locks),
-            event_counter: AtomicUsize::new(0),
-            earliest_time: MinCounter::new(),
-            latest_time: MaxCounter::new(),
-            node_meta: Meta::new(),
-            edge_meta: Meta::new(),
-            graph_meta: GraphMeta::new(),
-        }
-    }
-
-    pub fn process_prop_value(&self, prop: &Prop) -> Prop {
-        match prop {
-            Prop::Str(value) => Prop::Str(self.resolve_str(value)),
-            _ => prop.clone(),
-        }
-    }
-
-    fn get_valid_layers(edge_meta: &Meta) -> Vec<String> {
-        edge_meta
-            .layer_meta()
-            .get_keys()
-            .iter()
-            .map(|x| x.to_string())
-            .collect::<Vec<_>>()
-    }
-
-    pub fn num_layers(&self) -> usize {
-        self.edge_meta.layer_meta().len()
-    }
-
-    pub fn resolve_node_inner(&self, id: NodeRef) -> Result<MaybeNew<VID>, InvalidNodeId> {
-        match id {
-            NodeRef::External(id) => self.logical_to_physical.get_or_init_node(id, || {
-                let node_store = NodeStore::empty(id.into());
-                self.storage.push_node(node_store)
-            }),
-            NodeRef::Internal(id) => Ok(MaybeNew::Existing(id)),
-        }
-    }
-
-    /// map layer name to id and allocate a new layer if needed
-    pub fn resolve_layer_inner(
-        &self,
-        layer: Option<&str>,
-    ) -> Result<MaybeNew<usize>, TooManyLayers> {
-        let id = self.edge_meta.get_or_create_layer_id(layer);
-        if let MaybeNew::New(id) = id {
-            if id > MAX_LAYER {
-                Err(TooManyLayers)?;
-            }
-        }
-        Ok(id)
-    }
-
-    pub fn layer_ids(&self, key: Layer) -> Result<LayerIds, InvalidLayer> {
-        match key {
-            Layer::None => Ok(LayerIds::None),
-            Layer::All => Ok(LayerIds::All),
-            Layer::Default => Ok(LayerIds::One(0)),
-            Layer::One(id) => match self.edge_meta.get_layer_id(&id) {
-                Some(id) => Ok(LayerIds::One(id)),
-                None => Err(InvalidLayer::new(
-                    id,
-                    Self::get_valid_layers(&self.edge_meta),
-                )),
-            },
-            Layer::Multiple(ids) => {
-                let mut new_layers = ids
-                    .iter()
-                    .map(|id| {
-                        self.edge_meta.get_layer_id(id).ok_or_else(|| {
-                            InvalidLayer::new(id.clone(), Self::get_valid_layers(&self.edge_meta))
-                        })
-                    })
-                    .collect::<Result<Vec<_>, InvalidLayer>>()?;
-                let num_layers = self.num_layers();
-                let num_new_layers = new_layers.len();
-                if num_new_layers == 0 {
-                    Ok(LayerIds::None)
-                } else if num_new_layers == 1 {
-                    Ok(LayerIds::One(new_layers[0]))
-                } else if num_new_layers == num_layers {
-                    Ok(LayerIds::All)
-                } else {
-                    new_layers.sort_unstable();
-                    new_layers.dedup();
-                    Ok(LayerIds::Multiple(new_layers.into()))
-                }
-            }
-        }
-    }
-
-    pub fn valid_layer_ids(&self, key: Layer) -> LayerIds {
-        match key {
-            Layer::None => LayerIds::None,
-            Layer::All => LayerIds::All,
-            Layer::Default => LayerIds::One(0),
-            Layer::One(id) => match self.edge_meta.get_layer_id(&id) {
-                Some(id) => LayerIds::One(id),
-                None => LayerIds::None,
-            },
-            Layer::Multiple(ids) => {
-                let new_layers: Multiple = ids
-                    .iter()
-                    .flat_map(|id| self.edge_meta.get_layer_id(id))
-                    .collect();
-                let num_layers = self.num_layers();
-                let num_new_layers = new_layers.len();
-                if num_new_layers == 0 {
-                    LayerIds::None
-                } else if num_new_layers == 1 {
-                    LayerIds::One(new_layers.get_id_by_index(0).unwrap())
-                } else if num_new_layers == num_layers {
-                    LayerIds::All
-                } else {
-                    LayerIds::Multiple(new_layers)
-                }
-            }
-        }
-    }
-
-    pub fn get_layer_name(&self, layer: usize) -> ArcStr {
-        self.edge_meta.get_layer_name_by_id(layer)
-    }
-
-    #[inline]
-    pub fn graph_earliest_time(&self) -> Option<i64> {
-        Some(self.earliest_time.get()).filter(|t| *t != i64::MAX)
-    }
-
-    #[inline]
-    pub fn graph_latest_time(&self) -> Option<i64> {
-        Some(self.latest_time.get()).filter(|t| *t != i64::MIN)
-    }
-
-    #[inline]
-    pub fn internal_num_nodes(&self) -> usize {
-        self.storage.nodes.len()
-    }
-
-    #[inline]
-    pub fn update_time(&self, time: EventTime) {
-        let t = time.t();
-        self.earliest_time.update(t);
-        self.latest_time.update(t);
-    }
-
-    pub(crate) fn link_nodes_inner(
-        &self,
-        node_pair: &mut PairEntryMut,
-        edge_id: EID,
-        t: EventTime,
-        layer: usize,
-        is_deletion: bool,
-    ) {
-        self.update_time(t);
-        let src_id = node_pair.get_i().vid;
-        let dst_id = node_pair.get_j().vid;
-        let src = node_pair.get_mut_i();
-        let elid = if is_deletion {
-            edge_id.with_layer_deletion(layer)
-        } else {
-            edge_id.with_layer(layer)
-        };
-        src.add_edge(dst_id, Direction::OUT, layer, edge_id);
-        src.update_time(t, elid);
-        let dst = node_pair.get_mut_j();
-        dst.add_edge(src_id, Direction::IN, layer, edge_id);
-        dst.update_time(t, elid);
-    }
-
-    pub fn link_edge(
-        &self,
-        eid: EID,
-        t: EventTime,
-        layer: usize,
-        is_deletion: bool,
-    ) -> EdgeWGuard<'_> {
-        let (src, dst) = {
-            let edge_r = self.storage.edges.get_edge(eid);
-            let edge_r = edge_r.as_mem_edge().edge_store();
-            (edge_r.src, edge_r.dst)
-        };
-        // need to get the node pair first to avoid deadlocks with link_nodes
-        let mut node_pair = self.storage.pair_node_mut(src, dst);
-        self.link_nodes_inner(&mut node_pair, eid, t, layer, is_deletion);
-        self.storage.edges.get_edge_mut(eid)
-    }
-
-    pub fn link_nodes(
-        &self,
-        src_id: VID,
-        dst_id: VID,
-        t: EventTime,
-        layer: usize,
-        is_deletion: bool,
-    ) -> MaybeNew<EdgeWGuard<'_>> {
-        let edge = {
-            let mut node_pair = self.storage.pair_node_mut(src_id, dst_id);
-            let src = node_pair.get_i();
-            let mut edge = match src.find_edge_eid(dst_id, &LayerIds::All) {
-                Some(edge_id) => Either::Left(self.storage.get_edge_mut(edge_id)),
-                None => Either::Right(self.storage.push_edge(EdgeStore::new(src_id, dst_id))),
-            };
-            let eid = match edge.as_mut() {
-                Either::Left(edge) => edge.as_ref().eid(),
-                Either::Right(edge) => edge.value().eid,
-            };
-            self.link_nodes_inner(&mut node_pair, eid, t, layer, is_deletion);
-            edge
-        };
-
-        match edge {
-            Either::Left(edge) => MaybeNew::Existing(edge),
-            Either::Right(edge) => {
-                let edge = edge.init();
-                MaybeNew::New(edge)
-            }
-        }
-    }
-
-    #[inline]
-    pub fn resolve_node_ref(&self, v: NodeRef) -> Option<VID> {
-        match v {
-            NodeRef::Internal(vid) => Some(vid),
-            NodeRef::External(GidRef::U64(gid)) => self.logical_to_physical.get_u64(gid),
-            NodeRef::External(GidRef::Str(string)) => self
-                .logical_to_physical
-                .get_str(string)
-                .or_else(|| self.logical_to_physical.get_u64(string.id())),
-        }
-    }
-
-    /// Checks if the same string value already exists and returns a pointer to the same existing value if it exists,
-    /// otherwise adds the string to the pool.
-    fn resolve_str(&self, value: &ArcStr) -> ArcStr {
-        match self.string_pool.get(value) {
-            Some(value) => value.clone(),
-            None => {
-                self.string_pool.insert(value.clone());
-                self.string_pool
-                    .get(value)
-                    .expect("value should exist as inserted above")
-                    .clone()
-            }
-        }
-    }
-
-    pub fn node(&self, id: VID) -> NodeEntry<'_> {
-        self.storage.get_node(id)
-    }
-}
diff --git a/raphtory-core/src/entities/graph/tgraph_storage.rs b/raphtory-core/src/entities/graph/tgraph_storage.rs
deleted file mode 100644
index 2860dfa151..0000000000
--- a/raphtory-core/src/entities/graph/tgraph_storage.rs
+++ /dev/null
@@ -1,88 +0,0 @@
-use crate::{
-    entities::{edges::edge_store::EdgeStore, nodes::node_store::NodeStore, EID, VID},
-    storage::{
-        self,
-        raw_edges::{EdgeRGuard, EdgeWGuard, EdgesStorage, LockedEdges, UninitialisedEdge},
-        EntryMut, NodeEntry, NodeSlot, NodeStorage, PairEntryMut, UninitialisedEntry,
-    },
-};
-use parking_lot::RwLockWriteGuard;
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Deserialize, Serialize, PartialEq)]
-pub struct GraphStorage {
-    // node storage with having (id, time_index, properties, adj list for each layer)
-    pub nodes: NodeStorage,
-    pub edges: EdgesStorage,
-}
-
-impl GraphStorage {
-    pub fn new(num_locks: usize) -> Self {
-        Self {
-            nodes: storage::NodeStorage::new(num_locks),
-            edges: EdgesStorage::new(num_locks),
-        }
-    }
-
-    pub fn num_shards(&self) -> usize {
-        self.nodes.data.len()
-    }
-
-    #[inline]
-    pub fn nodes_read_lock(&self) -> storage::ReadLockedStorage {
-        self.nodes.read_lock()
-    }
-
-    #[inline]
-    pub fn edges_read_lock(&self) -> LockedEdges {
-        self.edges.read_lock()
-    }
-
-    #[inline]
-    pub fn nodes_len(&self) -> usize {
-        self.nodes.len()
-    }
-
-    #[inline]
-    pub fn edges_len(&self) -> usize {
-        self.edges.len()
-    }
-
-    #[inline]
-    pub fn push_node(&self, node: NodeStore) -> UninitialisedEntry<'_, NodeStore, NodeSlot> {
-        self.nodes.push(node)
-    }
-    #[inline]
-    pub fn push_edge(&self, edge: EdgeStore) -> UninitialisedEdge<'_> {
-        self.edges.push(edge)
-    }
-
-    #[inline]
-    pub fn get_node_mut(&self, id: VID) -> EntryMut<'_, RwLockWriteGuard<'_, NodeSlot>> {
-        self.nodes.entry_mut(id)
-    }
-
-    #[inline]
-    pub fn get_edge_mut(&self, eid: EID) -> EdgeWGuard<'_> {
-        self.edges.get_edge_mut(eid)
-    }
-
-    #[inline]
-    pub fn get_node(&self, id: VID) -> NodeEntry<'_> {
-        self.nodes.entry(id)
-    }
-
-    #[inline]
-    pub fn edge_entry(&self, eid: EID) -> EdgeRGuard<'_> {
-        self.edges.get_edge(eid)
-    }
-
-    pub fn try_edge_entry(&self, eid: EID) -> Option<EdgeRGuard<'_>> {
-        self.edges.try_get_edge(eid)
-    }
-
-    #[inline]
-    pub fn pair_node_mut(&self, i: VID, j: VID) -> PairEntryMut<'_> {
-        self.nodes.loop_pair_entry_mut(i, j)
-    }
-}
diff --git a/raphtory-core/src/entities/graph/timer.rs b/raphtory-core/src/entities/graph/timer.rs
index 7128bee016..69edcdfdf7 100644
--- a/raphtory-core/src/entities/graph/timer.rs
+++ b/raphtory-core/src/entities/graph/timer.rs
@@ -36,6 +36,13 @@ impl Default for MinCounter {
     }
 }
 
+impl From<i64> for MinCounter {
+    fn from(value: i64) -> Self {
+        let counter = AtomicI64::new(value);
+        Self { counter }
+    }
+}
+
 impl MinCounter {
     pub fn new() -> Self {
         Self {
@@ -60,6 +67,13 @@ pub struct MaxCounter {
     counter: AtomicI64,
 }
 
+impl From<i64> for MaxCounter {
+    fn from(value: i64) -> Self {
+        let counter = AtomicI64::new(value);
+        Self { counter }
+    }
+}
+
 impl Default for MaxCounter {
     fn default() -> Self {
         Self::new()
diff --git a/raphtory-core/src/entities/mod.rs b/raphtory-core/src/entities/mod.rs
index 0147447eaf..cd2323bd4d 100644
--- a/raphtory-core/src/entities/mod.rs
+++ b/raphtory-core/src/entities/mod.rs
@@ -1,4 +1,3 @@
-pub mod edges;
 pub mod graph;
 pub mod nodes;
 pub mod properties;
diff --git a/raphtory-core/src/entities/nodes/mod.rs b/raphtory-core/src/entities/nodes/mod.rs
index 094e8f0f17..3128f25de8 100644
--- a/raphtory-core/src/entities/nodes/mod.rs
+++ b/raphtory-core/src/entities/nodes/mod.rs
@@ -1,3 +1,2 @@
 pub mod node_ref;
-pub mod node_store;
 pub mod structure;
diff --git a/raphtory-core/src/entities/nodes/node_ref.rs b/raphtory-core/src/entities/nodes/node_ref.rs
index 86730b671f..732dbe0f8a 100644
--- a/raphtory-core/src/entities/nodes/node_ref.rs
+++ b/raphtory-core/src/entities/nodes/node_ref.rs
@@ -21,10 +21,10 @@ pub trait AsNodeRef: Send + Sync {
         }
     }
 
-    fn as_gid_ref(&self) -> Either<GidRef<'_>, VID> {
+    fn as_gid_ref(&self) -> Option<GidRef<'_>> {
         match self.as_node_ref() {
-            NodeRef::Internal(vid) => Either::Right(vid),
-            NodeRef::External(u) => Either::Left(u),
+            NodeRef::Internal(_) => None,
+            NodeRef::External(u) => Some(u),
         }
     }
 }
diff --git a/raphtory-core/src/entities/nodes/node_store.rs b/raphtory-core/src/entities/nodes/node_store.rs
deleted file mode 100644
index dbfd327775..0000000000
--- a/raphtory-core/src/entities/nodes/node_store.rs
+++ /dev/null
@@ -1,443 +0,0 @@
-use crate::{
-    entities::{
-        edges::edge_ref::EdgeRef,
-        nodes::structure::adj::Adj,
-        properties::{
-            props::{MetadataError, Props},
-            tcell::TCell,
-        },
-        LayerIds, EID, GID, VID,
-    },
-    storage::{
-        timeindex::{EventTime, TimeIndexWindow},
-        NodeEntry,
-    },
-    utils::iter::GenLockedIter,
-};
-use itertools::Itertools;
-use raphtory_api::{
-    core::{
-        entities::{properties::prop::Prop, GidRef, LayerVariants, ELID},
-        storage::timeindex::{TimeIndexLike, TimeIndexOps},
-        Direction,
-    },
-    iter::BoxedLIter,
-};
-use serde::{Deserialize, Serialize};
-use std::{iter, ops::Range};
-
-#[derive(Serialize, Deserialize, Debug, Default, PartialEq)]
-pub struct NodeStore {
-    pub global_id: GID,
-    pub vid: VID,
-    // each layer represents a separate view of the graph
-    pub(crate) layers: Vec<Adj>,
-    // props for node
-    pub(crate) props: Option<Props>,
-    pub node_type: usize,
-
-    /// For every property id keep a hash map of timestamps to values pointing to the property entries in the props vector
-    timestamps: NodeTimestamps,
-}
-
-#[derive(Serialize, Deserialize, Debug, Default, PartialEq)]
-pub struct NodeTimestamps {
-    // all the timestamps that have been seen by this node
-    pub edge_ts: TCell<ELID>,
-    pub props_ts: TCell<Option<usize>>,
-}
-
-impl NodeTimestamps {
-    pub fn edge_ts(&self) -> &TCell<ELID> {
-        &self.edge_ts
-    }
-
-    pub fn props_ts(&self) -> &TCell<Option<usize>> {
-        &self.props_ts
-    }
-}
-
-impl<'a> TimeIndexOps<'a> for &'a NodeTimestamps {
-    type IndexType = EventTime;
-    type RangeType = TimeIndexWindow<'a, EventTime, NodeTimestamps>;
-
-    #[inline]
-    fn active(&self, w: Range<Self::IndexType>) -> bool {
-        self.edge_ts().active(w.clone()) || self.props_ts().active(w)
-    }
-
-    fn range(&self, w: Range<Self::IndexType>) -> Self::RangeType {
-        TimeIndexWindow::Range {
-            timeindex: *self,
-            range: w,
-        }
-    }
-
-    fn first(&self) -> Option<Self::IndexType> {
-        let first = self.edge_ts().first();
-        let other = self.props_ts().first();
-
-        first
-            .zip(other)
-            .map(|(a, b)| a.min(b))
-            .or_else(|| first.or(other))
-    }
-
-    fn last(&self) -> Option<Self::IndexType> {
-        let last = self.edge_ts().last();
-        let other = self.props_ts().last();
-
-        last.zip(other)
-            .map(|(a, b)| a.max(b))
-            .or_else(|| last.or(other))
-    }
-
-    fn iter(self) -> impl Iterator<Item = Self::IndexType> + Send + Sync + 'a {
-        self.edge_ts
-            .iter()
-            .map(|(t, _)| *t)
-            .merge(self.props_ts.iter().map(|(t, _)| *t))
-    }
-
-    fn iter_rev(self) -> impl Iterator<Item = Self::IndexType> + Send + Sync + 'a {
-        self.edge_ts
-            .iter()
-            .rev()
-            .map(|(t, _)| *t)
-            .merge_by(self.props_ts.iter().rev().map(|(t, _)| *t), |lt, rt| {
-                lt >= rt
-            })
-    }
-
-    fn len(&self) -> usize {
-        self.edge_ts.len() + self.props_ts.len()
-    }
-}
-
-impl<'a> TimeIndexLike<'a> for &'a NodeTimestamps {
-    fn range_iter(
-        self,
-        w: Range<Self::IndexType>,
-    ) -> impl Iterator<Item = Self::IndexType> + Send + Sync + 'a {
-        self.edge_ts()
-            .range_iter(w.clone())
-            .merge(self.props_ts().range_iter(w))
-    }
-
-    fn range_iter_rev(
-        self,
-        w: Range<Self::IndexType>,
-    ) -> impl Iterator<Item = Self::IndexType> + Send + Sync + 'a {
-        self.edge_ts()
-            .range_iter_rev(w.clone())
-            .merge_by(self.props_ts().range_iter_rev(w), |lt, rt| lt >= rt)
-    }
-
-    fn range_count(&self, w: Range<Self::IndexType>) -> usize {
-        self.edge_ts().range_count(w.clone()) + self.props_ts().range_count(w)
-    }
-
-    fn first_range(&self, w: Range<Self::IndexType>) -> Option<Self::IndexType> {
-        let first = self
-            .edge_ts()
-            .iter_window(w.clone())
-            .next()
-            .map(|(t, _)| *t);
-        let other = self.props_ts().iter_window(w).next().map(|(t, _)| *t);
-
-        first
-            .zip(other)
-            .map(|(a, b)| a.min(b))
-            .or_else(|| first.or(other))
-    }
-
-    fn last_range(&self, w: Range<Self::IndexType>) -> Option<Self::IndexType> {
-        let last = self
-            .edge_ts
-            .iter_window(w.clone())
-            .next_back()
-            .map(|(t, _)| *t);
-        let other = self.props_ts.iter_window(w).next_back().map(|(t, _)| *t);
-
-        last.zip(other)
-            .map(|(a, b)| a.max(b))
-            .or_else(|| last.or(other))
-    }
-}
-
-impl NodeStore {
-    #[inline]
-    pub fn is_initialised(&self) -> bool {
-        self.vid != VID::default()
-    }
-
-    #[inline]
-    pub fn init(&mut self, vid: VID, gid: GidRef) {
-        if !self.is_initialised() {
-            self.vid = vid;
-            self.global_id = gid.to_owned();
-        }
-    }
-
-    pub fn empty(global_id: GID) -> Self {
-        let layers = vec![Adj::Solo];
-        Self {
-            global_id,
-            vid: VID(0),
-            timestamps: Default::default(),
-            layers,
-            props: None,
-            node_type: 0,
-        }
-    }
-
-    pub fn resolved(global_id: GID, vid: VID) -> Self {
-        Self {
-            global_id,
-            vid,
-            timestamps: Default::default(),
-            layers: vec![],
-            props: None,
-            node_type: 0,
-        }
-    }
-
-    pub fn global_id(&self) -> &GID {
-        &self.global_id
-    }
-
-    pub fn timestamps(&self) -> &NodeTimestamps {
-        &self.timestamps
-    }
-
-    #[inline]
-    pub fn update_time(&mut self, t: EventTime, eid: ELID) {
-        self.timestamps.edge_ts.set(t, eid);
-    }
-
-    pub fn update_node_type(&mut self, node_type: usize) -> usize {
-        self.node_type = node_type;
-        node_type
-    }
-
-    pub fn add_metadata(&mut self, prop_id: usize, prop: Prop) -> Result<(), MetadataError> {
-        let props = self.props.get_or_insert_with(Props::new);
-        props.add_metadata(prop_id, prop)
-    }
-
-    pub fn update_metadata(&mut self, prop_id: usize, prop: Prop) -> Result<(), MetadataError> {
-        let props = self.props.get_or_insert_with(Props::new);
-        props.update_metadata(prop_id, prop)
-    }
-
-    pub fn update_t_prop_time(&mut self, t: EventTime, prop_i: Option<usize>) {
-        self.timestamps.props_ts.set(t, prop_i);
-    }
-
-    #[inline(always)]
-    pub fn find_edge_eid(&self, dst: VID, layer_id: &LayerIds) -> Option<EID> {
-        match layer_id {
-            LayerIds::All => match self.layers.len() {
-                0 => None,
-                1 => self.layers[0].get_edge(dst, Direction::OUT),
-                _ => self
-                    .layers
-                    .iter()
-                    .find_map(|layer| layer.get_edge(dst, Direction::OUT)),
-            },
-            LayerIds::One(layer_id) => self
-                .layers
-                .get(*layer_id)
-                .and_then(|layer| layer.get_edge(dst, Direction::OUT)),
-            LayerIds::Multiple(layers) => layers.iter().find_map(|layer_id| {
-                self.layers
-                    .get(layer_id)
-                    .and_then(|layer| layer.get_edge(dst, Direction::OUT))
-            }),
-            LayerIds::None => None,
-        }
-    }
-
-    pub fn add_edge(&mut self, v_id: VID, dir: Direction, layer: usize, edge_id: EID) {
-        if layer >= self.layers.len() {
-            self.layers.resize_with(layer + 1, || Adj::Solo);
-        }
-
-        match dir {
-            Direction::IN => self.layers[layer].add_edge_into(v_id, edge_id),
-            Direction::OUT => self.layers[layer].add_edge_out(v_id, edge_id),
-            _ => {}
-        }
-    }
-
-    #[inline]
-    pub fn edge_tuples<'a>(&'a self, layers: &LayerIds, d: Direction) -> BoxedLIter<'a, EdgeRef> {
-        let self_id = self.vid;
-        let iter: BoxedLIter<'a, EdgeRef> = match d {
-            Direction::OUT => self.merge_layers(layers, Direction::OUT, self_id),
-            Direction::IN => self.merge_layers(layers, Direction::IN, self_id),
-            Direction::BOTH => Box::new(
-                self.edge_tuples(layers, Direction::OUT)
-                    .filter(|e| e.src() != e.dst())
-                    .merge_by(self.edge_tuples(layers, Direction::IN), |e1, e2| {
-                        e1.remote() < e2.remote()
-                    }),
-            ),
-        };
-        iter
-    }
-
-    fn merge_layers(
-        &self,
-        layers: &LayerIds,
-        d: Direction,
-        self_id: VID,
-    ) -> BoxedLIter<'_, EdgeRef> {
-        match layers {
-            LayerIds::All => Box::new(
-                self.layers
-                    .iter()
-                    .map(|adj| self.iter_adj(adj, d, self_id))
-                    .kmerge_by(|e1, e2| e1.remote() < e2.remote())
-                    .dedup(),
-            ),
-            LayerIds::One(id) => {
-                if let Some(layer) = self.layers.get(*id) {
-                    Box::new(self.iter_adj(layer, d, self_id))
-                } else {
-                    Box::new(iter::empty())
-                }
-            }
-            LayerIds::Multiple(ids) => Box::new(
-                ids.into_iter()
-                    .filter_map(|id| self.layers.get(id))
-                    .map(|layer| self.iter_adj(layer, d, self_id))
-                    .kmerge_by(|e1, e2| e1.remote() < e2.remote())
-                    .dedup(),
-            ),
-            LayerIds::None => Box::new(iter::empty()),
-        }
-    }
-
-    fn iter_adj<'a>(
-        &'a self,
-        layer: &'a Adj,
-        d: Direction,
-        self_id: VID,
-    ) -> impl Iterator<Item = EdgeRef> + Send + Sync + 'a {
-        let iter: BoxedLIter<'a, EdgeRef> = match d {
-            Direction::IN => Box::new(
-                layer
-                    .iter(d)
-                    .map(move |(src_pid, e_id)| EdgeRef::new_incoming(e_id, src_pid, self_id)),
-            ),
-            Direction::OUT => Box::new(
-                layer
-                    .iter(d)
-                    .map(move |(dst_pid, e_id)| EdgeRef::new_outgoing(e_id, self_id, dst_pid)),
-            ),
-            _ => Box::new(iter::empty()),
-        };
-        iter
-    }
-
-    pub fn degree(&self, layers: &LayerIds, d: Direction) -> usize {
-        match layers {
-            LayerIds::All => match self.layers.len() {
-                0 => 0,
-                1 => self.layers[0].degree(d),
-                _ => self
-                    .layers
-                    .iter()
-                    .map(|l| l.node_iter(d))
-                    .kmerge()
-                    .dedup()
-                    .count(),
-            },
-            LayerIds::One(l) => self
-                .layers
-                .get(*l)
-                .map(|layer| layer.degree(d))
-                .unwrap_or(0),
-            LayerIds::None => 0,
-            LayerIds::Multiple(ids) => ids
-                .iter()
-                .flat_map(|l_id| self.layers.get(l_id).map(|layer| layer.node_iter(d)))
-                .kmerge()
-                .dedup()
-                .count(),
-        }
-    }
-
-    // every neighbour apears once in the iterator
-    // this is important because it calculates degree
-    pub fn neighbours<'a>(
-        &'a self,
-        layers: &LayerIds,
-        d: Direction,
-    ) -> impl Iterator<Item = VID> + use<'a> {
-        match layers {
-            LayerIds::All => {
-                let iter = self
-                    .layers
-                    .iter()
-                    .map(move |layer| layer.node_iter(d))
-                    .kmerge()
-                    .dedup();
-                LayerVariants::All(iter)
-            }
-            LayerIds::One(one) => {
-                let iter = self
-                    .layers
-                    .get(*one)
-                    .into_iter()
-                    .flat_map(move |layer| layer.node_iter(d));
-                LayerVariants::One(iter)
-            }
-            LayerIds::Multiple(layers) => {
-                let iter = layers
-                    .into_iter()
-                    .filter_map(|l| self.layers.get(l))
-                    .map(move |layer| self.neighbours_from_adj(layer, d))
-                    .kmerge()
-                    .dedup();
-                LayerVariants::Multiple(iter)
-            }
-            LayerIds::None => LayerVariants::None(iter::empty()),
-        }
-    }
-
-    fn neighbours_from_adj<'a>(&'a self, layer: &'a Adj, d: Direction) -> BoxedLIter<'a, VID> {
-        let iter: BoxedLIter<'a, VID> = match d {
-            Direction::IN => Box::new(layer.iter(d).map(|(from_v, _)| from_v)),
-            Direction::OUT => Box::new(layer.iter(d).map(|(to_v, _)| to_v)),
-            Direction::BOTH => Box::new(
-                self.neighbours_from_adj(layer, Direction::OUT)
-                    .merge(self.neighbours_from_adj(layer, Direction::IN))
-                    .dedup(),
-            ),
-        };
-        iter
-    }
-
-    pub fn metadata_ids(&self) -> impl Iterator<Item = usize> + '_ {
-        self.props
-            .as_ref()
-            .into_iter()
-            .flat_map(|ps| ps.metadata_ids())
-    }
-
-    pub fn metadata(&self, prop_id: usize) -> Option<&Prop> {
-        self.props.as_ref().and_then(|ps| ps.metadata(prop_id))
-    }
-}
-
-impl<'a> NodeEntry<'a> {
-    pub fn into_edges(
-        self,
-        layers: &LayerIds,
-        dir: Direction,
-    ) -> impl Iterator<Item = EdgeRef> + 'a {
-        GenLockedIter::from(self, |node| node.as_ref().node().edge_tuples(layers, dir))
-    }
-}
diff --git a/raphtory-core/src/entities/nodes/structure/adj.rs b/raphtory-core/src/entities/nodes/structure/adj.rs
index 622b6ae939..743d1533d6 100644
--- a/raphtory-core/src/entities/nodes/structure/adj.rs
+++ b/raphtory-core/src/entities/nodes/structure/adj.rs
@@ -1,4 +1,5 @@
 use crate::entities::{edges::edge_ref::Dir, nodes::structure::adjset::AdjSet, EID, VID};
+use either::Either;
 use itertools::Itertools;
 use raphtory_api::{
     core::{Direction, DirectionVariants},
@@ -18,7 +19,7 @@ pub enum Adj {
 }
 
 impl Adj {
-    pub(crate) fn get_edge(&self, v: VID, dir: Direction) -> Option<EID> {
+    pub fn get_edge(&self, v: VID, dir: Direction) -> Option<EID> {
         match self {
             Adj::Solo => None,
             Adj::List { out, into } => match dir {
@@ -45,16 +46,24 @@ impl Adj {
         }
     }
 
-    pub(crate) fn add_edge_into(&mut self, v: VID, e: EID) {
+    pub fn add_edge_into(&mut self, v: VID, e: EID) -> bool {
         match self {
-            Adj::Solo => *self = Self::new_into(v, e),
+            Adj::Solo => {
+                *self = Self::new_into(v, e);
+                true
+            }
             Adj::List { into, .. } => into.push(v, e),
         }
     }
 
-    pub(crate) fn add_edge_out(&mut self, v: VID, e: EID) {
+    /// Adds an edge in the out direction, creating a new adjacency if necessary.
+    /// Returns `true` if the edge was added, `false` if it already exists.
+    pub fn add_edge_out(&mut self, v: VID, e: EID) -> bool {
         match self {
-            Adj::Solo => *self = Self::new_out(v, e),
+            Adj::Solo => {
+                *self = Self::new_out(v, e);
+                true
+            }
             Adj::List { out, .. } => out.push(v, e),
         }
     }
@@ -70,6 +79,20 @@ impl Adj {
         }
     }
 
+    pub fn out_iter(&self) -> impl Iterator<Item = (VID, EID)> + Send + Sync + '_ {
+        match self {
+            Adj::Solo => Either::Left(std::iter::empty()),
+            Adj::List { out, .. } => Either::Right(out.iter()),
+        }
+    }
+
+    pub fn inb_iter(&self) -> impl Iterator<Item = (VID, EID)> + Send + Sync + '_ {
+        match self {
+            Adj::Solo => Either::Left(std::iter::empty()),
+            Adj::List { into, .. } => Either::Right(into.iter()),
+        }
+    }
+
     pub fn node_iter(&self, dir: Direction) -> impl Iterator<Item = VID> + Send + '_ {
         let iter = self.iter(dir).map(|(v, _)| v);
         match dir {
diff --git a/raphtory-core/src/entities/nodes/structure/adjset.rs b/raphtory-core/src/entities/nodes/structure/adjset.rs
index 692fd9eea5..1409f93529 100644
--- a/raphtory-core/src/entities/nodes/structure/adjset.rs
+++ b/raphtory-core/src/entities/nodes/structure/adjset.rs
@@ -48,26 +48,36 @@ impl<K: Ord + Copy + Hash + Send + Sync, V: Into<usize> + Copy + Send + Sync> Ad
         Self::One(v, e)
     }
 
-    pub fn push(&mut self, v: K, e: V) {
+    /// Push a new node and edge into the adjacency set.
+    ///
+    /// If the node already exists, it will not be added again.
+    /// Returns `true` if the node was added, `false` if it already existed
+    pub fn push(&mut self, v: K, e: V) -> bool {
         match self {
             AdjSet::Empty => {
                 *self = Self::new(v, e);
+                true
             }
             AdjSet::One(vv, ee) => {
                 if *vv < v {
                     *self = Self::Small {
                         vs: vec![*vv, v],
                         edges: vec![*ee, e],
-                    }
+                    };
+                    true
                 } else if *vv > v {
                     *self = Self::Small {
                         vs: vec![v, *vv],
                         edges: vec![e, *ee],
-                    }
+                    };
+                    true
+                } else {
+                    // already exists
+                    false
                 }
             }
             AdjSet::Small { vs, edges } => match vs.binary_search(&v) {
-                Ok(_) => {}
+                Ok(_) => false,
                 Err(i) => {
                     if vs.len() < SMALL_SET {
                         vs.insert(i, v);
@@ -78,11 +88,10 @@ impl<K: Ord + Copy + Hash + Send + Sync, V: Into<usize> + Copy + Send + Sync> Ad
                         map.insert(v, e);
                         *self = Self::Large { vs: map }
                     }
+                    true
                 }
             },
-            AdjSet::Large { vs } => {
-                vs.insert(v, e);
-            }
+            AdjSet::Large { vs } => vs.insert(v, e).is_none(),
         }
     }
 
diff --git a/raphtory-core/src/entities/properties/graph_meta.rs b/raphtory-core/src/entities/properties/graph_meta.rs
index 42e89afce2..70a222a186 100644
--- a/raphtory-core/src/entities/properties/graph_meta.rs
+++ b/raphtory-core/src/entities/properties/graph_meta.rs
@@ -10,12 +10,16 @@ use raphtory_api::core::{
         meta::PropMapper,
         prop::{Prop, PropError, PropType},
     },
-    storage::{arc_str::ArcStr, dict_mapper::MaybeNew, locked_vec::ArcReadLockedVec, FxDashMap},
+    storage::{
+        arc_str::ArcStr,
+        dict_mapper::{MaybeNew, PublicKeys},
+        FxDashMap,
+    },
 };
-use serde::{Deserialize, Serialize};
+use serde::Serialize;
 use std::ops::{Deref, DerefMut};
 
-#[derive(Serialize, Deserialize, Debug, Default)]
+#[derive(Serialize, Debug, Default)]
 pub struct GraphMeta {
     metadata_mapper: PropMapper,
     temporal_mapper: PropMapper,
@@ -134,20 +138,20 @@ impl GraphMeta {
         self.metadata_mapper.get_dtype(prop_id)
     }
 
-    pub fn metadata_names(&self) -> ArcReadLockedVec<ArcStr> {
-        self.metadata_mapper.get_keys()
+    pub fn metadata_names(&self) -> PublicKeys<ArcStr> {
+        self.metadata_mapper.keys()
     }
 
     pub fn metadata_ids(&self) -> impl Iterator<Item = usize> {
-        0..self.metadata_mapper.len()
+        self.metadata_mapper.ids()
     }
 
-    pub fn temporal_names(&self) -> ArcReadLockedVec<ArcStr> {
-        self.temporal_mapper.get_keys()
+    pub fn temporal_names(&self) -> PublicKeys<ArcStr> {
+        self.temporal_mapper.keys()
     }
 
     pub fn temporal_ids(&self) -> impl Iterator<Item = usize> {
-        0..self.temporal_mapper.len()
+        self.temporal_mapper.ids()
     }
 
     pub fn metadata(&self) -> impl Iterator<Item = (usize, Prop)> + '_ {
@@ -159,6 +163,8 @@ impl GraphMeta {
     pub fn temporal_props(
         &self,
     ) -> impl Iterator<Item = (usize, impl Deref<Target = TProp> + '_)> + '_ {
-        (0..self.temporal_mapper.len()).filter_map(|id| self.temporal.get(&id).map(|v| (id, v)))
+        self.temporal_mapper
+            .ids()
+            .filter_map(|id| self.temporal.get(&id).map(|v| (id, v)))
     }
 }
diff --git a/raphtory-core/src/entities/properties/props.rs b/raphtory-core/src/entities/properties/props.rs
index 59028aecc1..63f6331afe 100644
--- a/raphtory-core/src/entities/properties/props.rs
+++ b/raphtory-core/src/entities/properties/props.rs
@@ -1,34 +1,27 @@
 use crate::{
-    entities::properties::tprop::{IllegalPropType, TProp},
-    storage::{
-        lazy_vec::{IllegalSet, LazyVec},
-        timeindex::EventTime,
-    },
+    entities::properties::tprop::IllegalPropType,
+    storage::{lazy_vec::IllegalSet, TPropColumnError},
 };
 use raphtory_api::core::entities::properties::prop::Prop;
-use serde::{Deserialize, Serialize};
 use std::fmt::Debug;
 use thiserror::Error;
 
-#[derive(Serialize, Deserialize, Default, Debug, PartialEq)]
-pub struct Props {
-    // properties
-    pub(crate) metadata: LazyVec<Option<Prop>>,
-    pub(crate) temporal_props: LazyVec<TProp>,
-}
-
 #[derive(Error, Debug)]
 pub enum TPropError {
     #[error(transparent)]
-    IllegalSet(#[from] IllegalSet<TProp>),
-    #[error(transparent)]
-    IllegalPropType(#[from] IllegalPropType),
+    ColumnError(#[from] TPropColumnError),
 }
 
 #[derive(Error, Debug)]
 pub enum MetadataError {
     #[error("Attempted to change value of metadata, old: {old}, new: {new}")]
     IllegalUpdate { old: Prop, new: Prop },
+
+    #[error(transparent)]
+    IllegalPropType(#[from] IllegalPropType),
+
+    #[error(transparent)]
+    ColumnError(#[from] TPropColumnError),
 }
 
 impl From<IllegalSet<Option<Prop>>> for MetadataError {
@@ -39,47 +32,6 @@ impl From<IllegalSet<Option<Prop>>> for MetadataError {
     }
 }
 
-impl Props {
-    pub fn new() -> Self {
-        Self {
-            metadata: Default::default(),
-            temporal_props: Default::default(),
-        }
-    }
-
-    pub fn add_prop(&mut self, t: EventTime, prop_id: usize, prop: Prop) -> Result<(), TPropError> {
-        self.temporal_props.update(prop_id, |p| Ok(p.set(t, prop)?))
-    }
-
-    pub fn add_metadata(&mut self, prop_id: usize, prop: Prop) -> Result<(), MetadataError> {
-        Ok(self.metadata.set(prop_id, Some(prop))?)
-    }
-
-    pub fn update_metadata(&mut self, prop_id: usize, prop: Prop) -> Result<(), MetadataError> {
-        self.metadata.update(prop_id, |n| {
-            *n = Some(prop);
-            Ok(())
-        })
-    }
-
-    pub fn metadata(&self, prop_id: usize) -> Option<&Prop> {
-        let prop = self.metadata.get(prop_id)?;
-        prop.as_ref()
-    }
-
-    pub fn temporal_prop(&self, prop_id: usize) -> Option<&TProp> {
-        self.temporal_props.get(prop_id)
-    }
-
-    pub fn metadata_ids(&self) -> impl Iterator<Item = usize> + '_ {
-        self.metadata.filled_ids()
-    }
-
-    pub fn temporal_prop_ids(&self) -> impl Iterator<Item = usize> + Send + Sync + '_ {
-        self.temporal_props.filled_ids()
-    }
-}
-
 #[cfg(test)]
 mod test {
     use super::*;
diff --git a/raphtory-core/src/entities/properties/tprop.rs b/raphtory-core/src/entities/properties/tprop.rs
index 66f63b0596..b6d426ba23 100644
--- a/raphtory-core/src/entities/properties/tprop.rs
+++ b/raphtory-core/src/entities/properties/tprop.rs
@@ -1,25 +1,25 @@
 use crate::{
     entities::properties::tcell::TCell,
-    storage::{timeindex::EventTime, TPropColumn},
+    storage::{timeindex::EventTime, PropColumn},
 };
 use bigdecimal::BigDecimal;
 use chrono::{DateTime, NaiveDateTime, Utc};
+use either::Either;
 use iter_enum::{DoubleEndedIterator, ExactSizeIterator, FusedIterator, Iterator};
-#[cfg(feature = "arrow")]
-use raphtory_api::core::entities::properties::prop::PropArray;
+
 use raphtory_api::core::{
     entities::properties::{
-        prop::{Prop, PropType},
+        prop::{Prop, PropArray, PropType},
         tprop::TPropOps,
     },
     storage::arc_str::ArcStr,
 };
 use rustc_hash::FxHashMap;
-use serde::{Deserialize, Serialize};
+use serde::Serialize;
 use std::{collections::HashMap, iter, ops::Range, sync::Arc};
 use thiserror::Error;
 
-#[derive(Debug, Default, PartialEq, Clone, Serialize, Deserialize)]
+#[derive(Debug, Default, PartialEq, Clone, Serialize)]
 pub enum TProp {
     #[default]
     Empty,
@@ -34,10 +34,8 @@ pub enum TProp {
     F64(TCell<f64>),
     Bool(TCell<bool>),
     DTime(TCell<DateTime<Utc>>),
-    #[cfg(feature = "arrow")]
-    Array(TCell<PropArray>),
+    List(TCell<PropArray>),
     NDTime(TCell<NaiveDateTime>),
-    List(TCell<Arc<Vec<Prop>>>),
     Map(TCell<Arc<FxHashMap<ArcStr, Prop>>>),
     Decimal(TCell<BigDecimal>),
 }
@@ -63,7 +61,6 @@ pub enum TPropVariants<
     F64,
     Bool,
     DTime,
-    #[cfg(feature = "arrow")] Array,
     NDTime,
     List,
     Map,
@@ -81,49 +78,78 @@ pub enum TPropVariants<
     F64(F64),
     Bool(Bool),
     DTime(DTime),
-    #[cfg(feature = "arrow")]
-    Array(Array),
     NDTime(NDTime),
     List(List),
     Map(Map),
     Decimal(Decimal),
 }
 
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, Debug, Default)]
 pub struct TPropCell<'a> {
     t_cell: Option<&'a TCell<Option<usize>>>,
-    log: Option<&'a TPropColumn>,
+    log: Option<&'a PropColumn>,
 }
 
 impl<'a> TPropCell<'a> {
-    pub(crate) fn new(t_cell: &'a TCell<Option<usize>>, log: Option<&'a TPropColumn>) -> Self {
+    pub fn new(t_cell: &'a TCell<Option<usize>>, log: Option<&'a PropColumn>) -> Self {
         Self {
             t_cell: Some(t_cell),
             log,
         }
     }
-}
 
-impl<'a> TPropOps<'a> for TPropCell<'a> {
-    fn iter(self) -> impl DoubleEndedIterator<Item = (EventTime, Prop)> + Send + Sync + 'a {
-        let log = self.log;
+    fn iter_window_inner(
+        self,
+        r: Range<EventTime>,
+    ) -> impl DoubleEndedIterator<Item = (EventTime, Prop)> + Send + 'a {
         self.t_cell.into_iter().flat_map(move |t_cell| {
             t_cell
-                .iter()
-                .filter_map(move |(t, &id)| log?.get(id?).map(|prop| (*t, prop)))
+                .iter_window(r.clone())
+                .filter_map(move |(t, &id)| self.log?.get(id?).map(|prop| (*t, prop)))
         })
     }
 
-    fn iter_window(
-        self,
-        r: Range<EventTime>,
-    ) -> impl DoubleEndedIterator<Item = (EventTime, Prop)> + Send + Sync + 'a {
+    fn iter_inner(self) -> impl DoubleEndedIterator<Item = (EventTime, Prop)> + Send + 'a {
         self.t_cell.into_iter().flat_map(move |t_cell| {
             t_cell
-                .iter_window(r.clone())
+                .iter()
                 .filter_map(move |(t, &id)| self.log?.get(id?).map(|prop| (*t, prop)))
         })
     }
+}
+
+impl<'a> TPropOps<'a> for TPropCell<'a> {
+    fn iter_inner(
+        self,
+        range: Option<Range<EventTime>>,
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'a {
+        match range {
+            Some(w) => {
+                let iter = self.iter_window_inner(w);
+                Either::Right(iter)
+            }
+            None => {
+                let iter = self.iter_inner();
+                Either::Left(iter)
+            }
+        }
+    }
+
+    fn iter_inner_rev(
+        self,
+        range: Option<Range<EventTime>>,
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'a {
+        match range {
+            Some(w) => {
+                let iter = self.iter_window_inner(w).rev();
+                Either::Right(iter)
+            }
+            None => {
+                let iter = self.iter_inner().rev();
+                Either::Left(iter)
+            }
+        }
+    }
 
     fn at(&self, ti: &EventTime) -> Option<Prop> {
         self.t_cell?.at(ti).and_then(|&id| self.log?.get(id?))
@@ -145,8 +171,6 @@ impl TProp {
             Prop::Bool(value) => TProp::Bool(TCell::new(t, value)),
             Prop::DTime(value) => TProp::DTime(TCell::new(t, value)),
             Prop::NDTime(value) => TProp::NDTime(TCell::new(t, value)),
-            #[cfg(feature = "arrow")]
-            Prop::Array(value) => TProp::Array(TCell::new(t, value)),
             Prop::List(value) => TProp::List(TCell::new(t, value)),
             Prop::Map(value) => TProp::Map(TCell::new(t, value)),
             Prop::Decimal(value) => TProp::Decimal(TCell::new(t, value)),
@@ -167,8 +191,6 @@ impl TProp {
             TProp::F64(_) => PropType::F64,
             TProp::Bool(_) => PropType::Bool,
             TProp::DTime(_) => PropType::DTime,
-            #[cfg(feature = "arrow")]
-            TProp::Array(_) => PropType::Array(Box::new(PropType::Empty)),
             TProp::NDTime(_) => PropType::NDTime,
             TProp::List(_) => PropType::List(Box::new(PropType::Empty)),
             TProp::Map(_) => PropType::Map(HashMap::new().into()),
@@ -219,10 +241,6 @@ impl TProp {
                 (TProp::NDTime(cell), Prop::NDTime(a)) => {
                     cell.set(t, a);
                 }
-                #[cfg(feature = "arrow")]
-                (TProp::Array(cell), Prop::Array(a)) => {
-                    cell.set(t, a);
-                }
                 (TProp::List(cell), Prop::List(a)) => {
                     cell.set(t, a);
                 }
@@ -242,98 +260,11 @@ impl TProp {
         }
         Ok(())
     }
-}
-
-impl<'a> TPropOps<'a> for &'a TProp {
-    fn last_before(&self, t: EventTime) -> Option<(EventTime, Prop)> {
-        match self {
-            TProp::Empty => None,
-            TProp::Str(cell) => cell.last_before(t).map(|(t, v)| (t, Prop::Str(v.clone()))),
-            TProp::I32(cell) => cell.last_before(t).map(|(t, v)| (t, Prop::I32(*v))),
-            TProp::I64(cell) => cell.last_before(t).map(|(t, v)| (t, Prop::I64(*v))),
-            TProp::U8(cell) => cell.last_before(t).map(|(t, v)| (t, Prop::U8(*v))),
-            TProp::U16(cell) => cell.last_before(t).map(|(t, v)| (t, Prop::U16(*v))),
-            TProp::U32(cell) => cell.last_before(t).map(|(t, v)| (t, Prop::U32(*v))),
-            TProp::U64(cell) => cell.last_before(t).map(|(t, v)| (t, Prop::U64(*v))),
-            TProp::F32(cell) => cell.last_before(t).map(|(t, v)| (t, Prop::F32(*v))),
-            TProp::F64(cell) => cell.last_before(t).map(|(t, v)| (t, Prop::F64(*v))),
-            TProp::Bool(cell) => cell.last_before(t).map(|(t, v)| (t, Prop::Bool(*v))),
-            TProp::DTime(cell) => cell.last_before(t).map(|(t, v)| (t, Prop::DTime(*v))),
-            TProp::NDTime(cell) => cell.last_before(t).map(|(t, v)| (t, Prop::NDTime(*v))),
-            #[cfg(feature = "arrow")]
-            TProp::Array(cell) => cell
-                .last_before(t)
-                .map(|(t, v)| (t, Prop::Array(v.clone()))),
-            TProp::List(cell) => cell.last_before(t).map(|(t, v)| (t, Prop::List(v.clone()))),
-            TProp::Map(cell) => cell.last_before(t).map(|(t, v)| (t, Prop::Map(v.clone()))),
-            TProp::Decimal(cell) => cell
-                .last_before(t)
-                .map(|(t, v)| (t, Prop::Decimal(v.clone()))),
-        }
-    }
-
-    fn iter(self) -> impl DoubleEndedIterator<Item = (EventTime, Prop)> + Send + Sync + 'a {
-        match self {
-            TProp::Empty => TPropVariants::Empty(iter::empty()),
-            TProp::Str(cell) => {
-                TPropVariants::Str(cell.iter().map(|(t, value)| (*t, Prop::Str(value.clone()))))
-            }
-            TProp::I32(cell) => {
-                TPropVariants::I32(cell.iter().map(|(t, value)| (*t, Prop::I32(*value))))
-            }
-            TProp::I64(cell) => {
-                TPropVariants::I64(cell.iter().map(|(t, value)| (*t, Prop::I64(*value))))
-            }
-            TProp::U8(cell) => {
-                TPropVariants::U8(cell.iter().map(|(t, value)| (*t, Prop::U8(*value))))
-            }
-            TProp::U16(cell) => {
-                TPropVariants::U16(cell.iter().map(|(t, value)| (*t, Prop::U16(*value))))
-            }
-            TProp::U32(cell) => {
-                TPropVariants::U32(cell.iter().map(|(t, value)| (*t, Prop::U32(*value))))
-            }
-            TProp::U64(cell) => {
-                TPropVariants::U64(cell.iter().map(|(t, value)| (*t, Prop::U64(*value))))
-            }
-            TProp::F32(cell) => {
-                TPropVariants::F32(cell.iter().map(|(t, value)| (*t, Prop::F32(*value))))
-            }
-            TProp::F64(cell) => {
-                TPropVariants::F64(cell.iter().map(|(t, value)| (*t, Prop::F64(*value))))
-            }
-            TProp::Bool(cell) => {
-                TPropVariants::Bool(cell.iter().map(|(t, value)| (*t, Prop::Bool(*value))))
-            }
-            TProp::DTime(cell) => {
-                TPropVariants::DTime(cell.iter().map(|(t, value)| (*t, Prop::DTime(*value))))
-            }
-            TProp::NDTime(cell) => {
-                TPropVariants::NDTime(cell.iter().map(|(t, value)| (*t, Prop::NDTime(*value))))
-            }
-            #[cfg(feature = "arrow")]
-            TProp::Array(cell) => TPropVariants::Array(
-                cell.iter()
-                    .map(|(t, value)| (*t, Prop::Array(value.clone()))),
-            ),
-            TProp::List(cell) => TPropVariants::List(
-                cell.iter()
-                    .map(|(t, value)| (*t, Prop::List(value.clone()))),
-            ),
-            TProp::Map(cell) => {
-                TPropVariants::Map(cell.iter().map(|(t, value)| (*t, Prop::Map(value.clone()))))
-            }
-            TProp::Decimal(cell) => TPropVariants::Decimal(
-                cell.iter()
-                    .map(|(t, value)| (*t, Prop::Decimal(value.clone()))),
-            ),
-        }
-    }
 
-    fn iter_window(
-        self,
+    pub(crate) fn iter_window_inner(
+        &self,
         r: Range<EventTime>,
-    ) -> impl DoubleEndedIterator<Item = (EventTime, Prop)> + Send + Sync + 'a {
+    ) -> impl DoubleEndedIterator<Item = (EventTime, Prop)> + Send + Sync + '_ {
         match self {
             TProp::Empty => TPropVariants::Empty(iter::empty()),
             TProp::Str(cell) => TPropVariants::Str(
@@ -383,11 +314,6 @@ impl<'a> TPropOps<'a> for &'a TProp {
                 cell.iter_window(r)
                     .map(|(t, value)| (*t, Prop::NDTime(*value))),
             ),
-            #[cfg(feature = "arrow")]
-            TProp::Array(cell) => TPropVariants::Array(
-                cell.iter_window(r)
-                    .map(|(t, value)| (*t, Prop::Array(value.clone()))),
-            ),
             TProp::List(cell) => TPropVariants::List(
                 cell.iter_window(r)
                     .map(|(t, value)| (*t, Prop::List(value.clone()))),
@@ -403,6 +329,86 @@ impl<'a> TPropOps<'a> for &'a TProp {
         }
     }
 
+    pub(crate) fn iter_inner(
+        &self,
+    ) -> impl DoubleEndedIterator<Item = (EventTime, Prop)> + Send + Sync + '_ {
+        match self {
+            TProp::Empty => TPropVariants::Empty(iter::empty()),
+            TProp::Str(cell) => {
+                TPropVariants::Str(cell.iter().map(|(t, value)| (*t, Prop::Str(value.clone()))))
+            }
+            TProp::I32(cell) => {
+                TPropVariants::I32(cell.iter().map(|(t, value)| (*t, Prop::I32(*value))))
+            }
+            TProp::I64(cell) => {
+                TPropVariants::I64(cell.iter().map(|(t, value)| (*t, Prop::I64(*value))))
+            }
+            TProp::U8(cell) => {
+                TPropVariants::U8(cell.iter().map(|(t, value)| (*t, Prop::U8(*value))))
+            }
+            TProp::U16(cell) => {
+                TPropVariants::U16(cell.iter().map(|(t, value)| (*t, Prop::U16(*value))))
+            }
+            TProp::U32(cell) => {
+                TPropVariants::U32(cell.iter().map(|(t, value)| (*t, Prop::U32(*value))))
+            }
+            TProp::U64(cell) => {
+                TPropVariants::U64(cell.iter().map(|(t, value)| (*t, Prop::U64(*value))))
+            }
+            TProp::F32(cell) => {
+                TPropVariants::F32(cell.iter().map(|(t, value)| (*t, Prop::F32(*value))))
+            }
+            TProp::F64(cell) => {
+                TPropVariants::F64(cell.iter().map(|(t, value)| (*t, Prop::F64(*value))))
+            }
+            TProp::Bool(cell) => {
+                TPropVariants::Bool(cell.iter().map(|(t, value)| (*t, Prop::Bool(*value))))
+            }
+            TProp::DTime(cell) => {
+                TPropVariants::DTime(cell.iter().map(|(t, value)| (*t, Prop::DTime(*value))))
+            }
+            TProp::NDTime(cell) => {
+                TPropVariants::NDTime(cell.iter().map(|(t, value)| (*t, Prop::NDTime(*value))))
+            }
+            TProp::List(cell) => TPropVariants::List(
+                cell.iter()
+                    .map(|(t, value)| (*t, Prop::List(value.clone()))),
+            ),
+            TProp::Map(cell) => {
+                TPropVariants::Map(cell.iter().map(|(t, value)| (*t, Prop::Map(value.clone()))))
+            }
+            TProp::Decimal(cell) => TPropVariants::Decimal(
+                cell.iter()
+                    .map(|(t, value)| (*t, Prop::Decimal(value.clone()))),
+            ),
+        }
+    }
+}
+
+impl<'a> TPropOps<'a> for &'a TProp {
+    fn last_before(&self, t: EventTime) -> Option<(EventTime, Prop)> {
+        match self {
+            TProp::Empty => None,
+            TProp::Str(cell) => cell.last_before(t).map(|(t, v)| (t, Prop::Str(v.clone()))),
+            TProp::I32(cell) => cell.last_before(t).map(|(t, v)| (t, Prop::I32(*v))),
+            TProp::I64(cell) => cell.last_before(t).map(|(t, v)| (t, Prop::I64(*v))),
+            TProp::U8(cell) => cell.last_before(t).map(|(t, v)| (t, Prop::U8(*v))),
+            TProp::U16(cell) => cell.last_before(t).map(|(t, v)| (t, Prop::U16(*v))),
+            TProp::U32(cell) => cell.last_before(t).map(|(t, v)| (t, Prop::U32(*v))),
+            TProp::U64(cell) => cell.last_before(t).map(|(t, v)| (t, Prop::U64(*v))),
+            TProp::F32(cell) => cell.last_before(t).map(|(t, v)| (t, Prop::F32(*v))),
+            TProp::F64(cell) => cell.last_before(t).map(|(t, v)| (t, Prop::F64(*v))),
+            TProp::Bool(cell) => cell.last_before(t).map(|(t, v)| (t, Prop::Bool(*v))),
+            TProp::DTime(cell) => cell.last_before(t).map(|(t, v)| (t, Prop::DTime(*v))),
+            TProp::NDTime(cell) => cell.last_before(t).map(|(t, v)| (t, Prop::NDTime(*v))),
+            TProp::List(cell) => cell.last_before(t).map(|(t, v)| (t, Prop::List(v.clone()))),
+            TProp::Map(cell) => cell.last_before(t).map(|(t, v)| (t, Prop::Map(v.clone()))),
+            TProp::Decimal(cell) => cell
+                .last_before(t)
+                .map(|(t, v)| (t, Prop::Decimal(v.clone()))),
+        }
+    }
+
     fn at(&self, ti: &EventTime) -> Option<Prop> {
         match self {
             TProp::Empty => None,
@@ -418,13 +424,43 @@ impl<'a> TPropOps<'a> for &'a TProp {
             TProp::Bool(cell) => cell.at(ti).map(|v| Prop::Bool(*v)),
             TProp::DTime(cell) => cell.at(ti).map(|v| Prop::DTime(*v)),
             TProp::NDTime(cell) => cell.at(ti).map(|v| Prop::NDTime(*v)),
-            #[cfg(feature = "arrow")]
-            TProp::Array(cell) => cell.at(ti).map(|v| Prop::Array(v.clone())),
             TProp::List(cell) => cell.at(ti).map(|v| Prop::List(v.clone())),
             TProp::Map(cell) => cell.at(ti).map(|v| Prop::Map(v.clone())),
             TProp::Decimal(cell) => cell.at(ti).map(|v| Prop::Decimal(v.clone())),
         }
     }
+
+    fn iter_inner(
+        self,
+        range: Option<Range<EventTime>>,
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'a {
+        match range {
+            Some(w) => {
+                let iter = self.iter_window_inner(w);
+                Either::Right(iter)
+            }
+            None => {
+                let iter = self.iter_inner();
+                Either::Left(iter)
+            }
+        }
+    }
+
+    fn iter_inner_rev(
+        self,
+        range: Option<Range<EventTime>>,
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'a {
+        match range {
+            Some(w) => {
+                let iter = self.iter_window_inner(w).rev();
+                Either::Right(iter)
+            }
+            None => {
+                let iter = self.iter_inner().rev();
+                Either::Left(iter)
+            }
+        }
+    }
 }
 
 #[cfg(test)]
@@ -435,7 +471,7 @@ mod tprop_tests {
 
     #[test]
     fn t_prop_cell() {
-        let col = TPropColumn::Bool(LazyVec::from(0, true));
+        let col = PropColumn::Bool(LazyVec::from(0, true));
         assert_eq!(col.get(0), Some(Prop::Bool(true)));
 
         let t_prop = TPropCell::new(&TCell::TCell1(EventTime(0, 0), Some(0)), Some(&col));
diff --git a/raphtory-core/src/lib.rs b/raphtory-core/src/lib.rs
index 791b0765ae..c754214f76 100644
--- a/raphtory-core/src/lib.rs
+++ b/raphtory-core/src/lib.rs
@@ -24,24 +24,8 @@
 //!    * `macOS`
 //!
 
-use std::{thread, time::Duration};
-
-use parking_lot::RwLock;
-
 pub mod entities;
 #[cfg(feature = "python")]
 mod python;
 pub mod storage;
 pub mod utils;
-
-pub(crate) fn loop_lock_write<A>(l: &RwLock<A>) -> parking_lot::RwLockWriteGuard<'_, A> {
-    const MAX_BACKOFF_US: u64 = 1000; // 1ms max
-    let mut backoff_us = 1;
-    loop {
-        if let Some(guard) = l.try_write_for(Duration::from_micros(50)) {
-            return guard;
-        }
-        thread::park_timeout(Duration::from_micros(backoff_us));
-        backoff_us = (backoff_us * 2).min(MAX_BACKOFF_US);
-    }
-}
diff --git a/raphtory-core/src/python/time.rs b/raphtory-core/src/python/time.rs
index 4c988dcee9..3d22db4146 100644
--- a/raphtory-core/src/python/time.rs
+++ b/raphtory-core/src/python/time.rs
@@ -1,8 +1,9 @@
 use crate::utils::time::{AlignmentUnit, Interval};
-use pyo3::{exceptions::PyTypeError, prelude::*, Bound, FromPyObject, PyAny, PyResult};
+use pyo3::{exceptions::PyTypeError, prelude::*, FromPyObject, PyAny, PyResult};
 
-impl<'source> FromPyObject<'source> for Interval {
-    fn extract_bound(interval: &Bound<'source, PyAny>) -> PyResult<Self> {
+impl<'py> FromPyObject<'_, 'py> for Interval {
+    type Error = PyErr;
+    fn extract(interval: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
         if let Ok(string) = interval.extract::<String>() {
             return Ok(string.try_into()?);
         };
@@ -12,17 +13,20 @@ impl<'source> FromPyObject<'source> for Interval {
         };
 
         Err(PyTypeError::new_err(format!(
-            "interval '{interval}' must be a str or an unsigned integer"
+            "interval '{interval:?}' must be a str or an unsigned integer"
         )))
     }
 }
 
-impl<'source> FromPyObject<'source> for AlignmentUnit {
-    fn extract_bound(unit: &Bound<'source, PyAny>) -> PyResult<Self> {
+impl<'py> FromPyObject<'_, 'py> for AlignmentUnit {
+    type Error = PyErr;
+    fn extract(unit: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
         if let Ok(string) = unit.extract::<String>() {
             return Ok(string.try_into()?);
         };
 
-        Err(PyTypeError::new_err(format!("unit '{unit}' must be a str")))
+        Err(PyTypeError::new_err(format!(
+            "unit '{unit:?}' must be a str"
+        )))
     }
 }
diff --git a/raphtory-core/src/storage/lazy_vec.rs b/raphtory-core/src/storage/lazy_vec.rs
index bafe78a507..c2085f432a 100644
--- a/raphtory-core/src/storage/lazy_vec.rs
+++ b/raphtory-core/src/storage/lazy_vec.rs
@@ -1,6 +1,6 @@
-use raphtory_api::iter::BoxedLIter;
+use arrow_array::BooleanArray;
 use serde::{Deserialize, Serialize};
-use std::{fmt::Debug, iter};
+use std::fmt::Debug;
 
 #[derive(thiserror::Error, Debug, PartialEq)]
 #[error("Cannot set previous value '{previous_value:?}' to '{new_value:?}' in position '{index}'")]
@@ -167,49 +167,81 @@ impl<A> LazyVec<A>
 where
     A: PartialEq + Default + Debug + Sync + Send + Clone,
 {
+    pub fn append(&mut self, items: impl IntoIterator<Item = Option<A>>, mask: &BooleanArray) {
+        if !matches!(self, LazyVec::LazyVecN(_, _)) {
+            match self {
+                LazyVec::Empty => {
+                    *self = LazyVec::LazyVecN(A::default(), MaskedCol::default());
+                }
+                LazyVec::LazyVec1(_, tuples) => {
+                    let mut take = TupleCol::default();
+                    std::mem::swap(&mut take, tuples);
+                    *self = LazyVec::LazyVecN(A::default(), MaskedCol::from(take));
+                }
+                _ => {}
+            }
+        }
+
+        match self {
+            LazyVec::LazyVecN(_, vector) => {
+                for (item, is_valid) in items.into_iter().zip(mask.values().iter()) {
+                    if is_valid {
+                        vector.push(item);
+                    }
+                }
+            }
+            _ => unreachable!(),
+        }
+    }
+
     // fails if there is already a value set for the given id to a different value
-    pub(crate) fn set(&mut self, id: usize, value: A) -> Result<(), IllegalSet<A>> {
+    pub fn upsert(&mut self, id: usize, value: A) {
         match self {
             LazyVec::Empty => {
                 *self = Self::from(id, value);
-                Ok(())
             }
+            LazyVec::LazyVec1(_, tuples) => {
+                tuples.upsert(id, Some(value));
+                self.swap_lazy_types();
+            }
+            LazyVec::LazyVecN(_, vector) => {
+                vector.upsert(id, Some(value));
+            }
+        }
+    }
+
+    /// checks if there is already a different value for a given id
+    pub fn check(&self, id: usize, value: &A) -> Result<(), IllegalSet<A>> {
+        match self {
+            LazyVec::Empty => {}
             LazyVec::LazyVec1(_, tuples) => {
                 if let Some(only_value) = tuples.get(id) {
-                    if only_value != &value {
-                        return Err(IllegalSet::new(id, only_value.clone(), value));
+                    if only_value != value {
+                        return Err(IllegalSet::new(id, only_value.clone(), value.clone()));
                     }
-                } else {
-                    tuples.upsert(id, Some(value));
-
-                    self.swap_lazy_types();
                 }
-                Ok(())
             }
             LazyVec::LazyVecN(_, vector) => {
                 if let Some(only_value) = vector.get(id) {
-                    if only_value != &value {
-                        return Err(IllegalSet::new(id, only_value.clone(), value));
+                    if only_value != value {
+                        return Err(IllegalSet::new(id, only_value.clone(), value.clone()));
                     }
-                } else {
-                    vector.upsert(id, Some(value));
                 }
-                Ok(())
             }
         }
+        Ok(())
     }
 
-    pub(crate) fn update<F, B, E>(&mut self, id: usize, updater: F) -> Result<B, E>
+    pub fn update<F, B, E>(&mut self, id: usize, updater: F) -> Result<B, E>
     where
         F: FnOnce(&mut A) -> Result<B, E>,
-        E: From<IllegalSet<A>>,
     {
         let b = match self.get_mut(id) {
             Some(value) => updater(value)?,
             None => {
                 let mut value = A::default();
                 let b = updater(&mut value)?;
-                self.set(id, value)?;
+                self.upsert(id, value);
                 b
             }
         };
@@ -241,28 +273,9 @@ where
         LazyVec::LazyVec1(A::default(), TupleCol::from(inner))
     }
 
-    pub(crate) fn filled_ids(&self) -> BoxedLIter<'_, usize> {
+    pub fn iter(&self) -> Box<dyn Iterator<Item = &A> + Send + '_> {
         match self {
-            LazyVec::Empty => Box::new(iter::empty()),
-            LazyVec::LazyVec1(_, tuples) => Box::new(
-                tuples
-                    .iter()
-                    .enumerate()
-                    .filter_map(|(id, value)| value.map(|_| id)),
-            ),
-            LazyVec::LazyVecN(_, vector) => Box::new(
-                vector
-                    .iter()
-                    .enumerate()
-                    .filter_map(|(id, value)| value.map(|_| id)),
-            ),
-        }
-    }
-
-    #[cfg(test)]
-    fn iter(&self) -> Box<dyn Iterator<Item = &A> + Send + '_> {
-        match self {
-            LazyVec::Empty => Box::new(iter::empty()),
+            LazyVec::Empty => Box::new(std::iter::empty()),
             LazyVec::LazyVec1(default, tuples) => {
                 Box::new(tuples.iter().map(|value| value.unwrap_or(default)))
             }
@@ -272,16 +285,15 @@ where
         }
     }
 
-    #[cfg(test)]
-    fn iter_opt(&self) -> Box<dyn Iterator<Item = Option<&A>> + Send + '_> {
+    pub fn iter_opt(&self) -> Box<dyn Iterator<Item = Option<&A>> + Send + '_> {
         match self {
-            LazyVec::Empty => Box::new(iter::empty()),
+            LazyVec::Empty => Box::new(std::iter::empty()),
             LazyVec::LazyVec1(_, tuples) => Box::new(tuples.iter()),
             LazyVec::LazyVecN(_, vector) => Box::new(vector.iter()),
         }
     }
 
-    pub(crate) fn get(&self, id: usize) -> Option<&A> {
+    pub fn get(&self, id: usize) -> Option<&A> {
         match self {
             LazyVec::LazyVec1(default, tuples) => tuples
                 .get(id)
@@ -293,7 +305,7 @@ where
         }
     }
 
-    pub(crate) fn get_opt(&self, id: usize) -> Option<&A> {
+    pub fn get_opt(&self, id: usize) -> Option<&A> {
         match self {
             LazyVec::LazyVec1(_, tuples) => tuples.get(id),
             LazyVec::LazyVecN(_, vec) => vec.get(id),
@@ -341,7 +353,6 @@ where
 #[cfg(test)]
 mod lazy_vec_tests {
     use super::*;
-    use itertools::Itertools;
     use proptest::{arbitrary::Arbitrary, proptest};
 
     fn check_lazy_vec(lazy_vec: &LazyVec<u32>, v: Vec<Option<u32>>) {
@@ -404,9 +415,9 @@ mod lazy_vec_tests {
     fn normal_operation() {
         let mut vec = LazyVec::<u32>::Empty;
 
-        vec.set(5, 55).unwrap();
-        vec.set(1, 11).unwrap();
-        vec.set(8, 88).unwrap();
+        vec.upsert(5, 55);
+        vec.upsert(1, 11);
+        vec.upsert(8, 88);
         assert_eq!(vec.get(5), Some(&55));
         assert_eq!(vec.get(1), Some(&11));
         assert_eq!(vec.get(0), Some(&0));
@@ -431,14 +442,12 @@ mod lazy_vec_tests {
         })
         .unwrap();
         assert_eq!(vec.get(9), Some(&1));
-
-        assert_eq!(vec.filled_ids().collect_vec(), vec![1, 5, 6, 8, 9]);
     }
 
     #[test]
-    fn set_fails_if_present() {
-        let mut vec = LazyVec::from(5, 55);
-        let result = vec.set(5, 555);
+    fn check_fails_if_present() {
+        let vec = LazyVec::from(5, 55);
+        let result = vec.check(5, &555);
         assert_eq!(result, Err(IllegalSet::new(5, 55, 555)))
     }
 }
diff --git a/raphtory-core/src/storage/mod.rs b/raphtory-core/src/storage/mod.rs
index 5390f90170..96107238cc 100644
--- a/raphtory-core/src/storage/mod.rs
+++ b/raphtory-core/src/storage/mod.rs
@@ -1,124 +1,95 @@
 use crate::{
-    entities::{
-        nodes::node_store::NodeStore,
-        properties::{props::TPropError, tprop::IllegalPropType},
-    },
-    loop_lock_write,
+    entities::properties::{props::TPropError, tprop::IllegalPropType},
     storage::lazy_vec::IllegalSet,
 };
-use bigdecimal::BigDecimal;
-use itertools::Itertools;
+use arrow_schema::ArrowError;
+use bigdecimal::{num_bigint::BigInt, BigDecimal};
 use lazy_vec::LazyVec;
-use lock_api;
-use node_entry::NodePtr;
-use parking_lot::{RwLock, RwLockReadGuard, RwLockWriteGuard};
-#[cfg(feature = "arrow")]
-use raphtory_api::core::entities::properties::prop::PropArray;
 use raphtory_api::core::{
-    entities::{
-        properties::prop::{Prop, PropType},
-        GidRef, VID,
-    },
+    entities::properties::prop::{prop_col::PropCol, AsPropRef, Prop, PropRef, PropType},
     storage::arc_str::ArcStr,
 };
-use rayon::prelude::*;
 use rustc_hash::FxHashMap;
-use serde::{Deserialize, Serialize};
-use std::{
-    collections::HashMap,
-    fmt::{Debug, Formatter},
-    marker::PhantomData,
-    ops::{Deref, DerefMut, Index, IndexMut},
-    sync::{
-        atomic::{AtomicUsize, Ordering},
-        Arc,
-    },
-};
+use std::{borrow::Cow, collections::HashMap, fmt::Debug, sync::Arc};
 use thiserror::Error;
 
+use crate::storage::string_col::StringCol;
+use raphtory_api::core::entities::properties::prop::{
+    IntoProp, PropArray, PropMapRef, PropNum, PropUnwrap,
+};
+
 pub mod lazy_vec;
 pub mod locked_view;
-pub mod node_entry;
-pub mod raw_edges;
+mod string_col;
 pub mod timeindex;
 
-type ArcRwLockReadGuard<T> = lock_api::ArcRwLockReadGuard<parking_lot::RawRwLock, T>;
-#[must_use]
-pub struct UninitialisedEntry<'a, T, TS> {
-    offset: usize,
-    guard: RwLockWriteGuard<'a, TS>,
-    value: T,
-}
-
-impl<'a, T: Default, TS: DerefMut<Target = Vec<T>>> UninitialisedEntry<'a, T, TS> {
-    pub fn init(mut self) {
-        if self.offset >= self.guard.len() {
-            self.guard.resize_with(self.offset + 1, Default::default);
-        }
-        self.guard[self.offset] = self.value;
-    }
-    pub fn value(&self) -> &T {
-        &self.value
-    }
-}
-
-#[inline]
-fn resolve(index: usize, num_buckets: usize) -> (usize, usize) {
-    let bucket = index % num_buckets;
-    let offset = index / num_buckets;
-    (bucket, offset)
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone)]
-pub struct NodeVec {
-    data: Arc<RwLock<NodeSlot>>,
-}
-
-#[derive(Debug, Serialize, Deserialize, PartialEq, Default)]
-pub struct NodeSlot {
-    nodes: Vec<NodeStore>,
-    t_props_log: TColumns, // not the same size as nodes
-}
-
-#[derive(Debug, Serialize, Deserialize, PartialEq, Default)]
+#[derive(Debug, Default)]
 pub struct TColumns {
-    t_props_log: Vec<TPropColumn>,
+    t_props_log: Vec<PropColumn>,
     num_rows: usize,
 }
 
 impl TColumns {
-    pub fn push(
+    pub fn push<P: AsPropRef>(
         &mut self,
-        row: impl IntoIterator<Item = (usize, Prop)>,
+        props: impl IntoIterator<Item = (usize, P)>,
     ) -> Result<Option<usize>, TPropError> {
         let id = self.num_rows;
         let mut has_props = false;
 
-        for (prop_id, prop) in row {
+        for (prop_id, prop) in props {
             match self.t_props_log.get_mut(prop_id) {
-                Some(col) => col.push(prop)?,
+                Some(col) => col.push(prop.as_prop_ref())?,
                 None => {
-                    let col: TPropColumn = TPropColumn::new(self.num_rows, prop);
+                    let col = PropColumn::new(self.num_rows, prop.as_prop_ref());
+
                     self.t_props_log
-                        .resize_with(prop_id + 1, || TPropColumn::Empty(id));
+                        .resize_with(prop_id + 1, || PropColumn::Empty(id));
                     self.t_props_log[prop_id] = col;
                 }
             }
+
             has_props = true;
         }
 
         if has_props {
             self.num_rows += 1;
+
             for col in self.t_props_log.iter_mut() {
                 col.grow(self.num_rows);
             }
+
             Ok(Some(id))
         } else {
             Ok(None)
         }
     }
 
-    pub(crate) fn get(&self, prop_id: usize) -> Option<&TPropColumn> {
+    pub fn ensure_column(&mut self, prop_id: usize) {
+        if self.t_props_log.len() <= prop_id {
+            self.t_props_log
+                .resize_with(prop_id + 1, || PropColumn::Empty(self.num_rows));
+        }
+    }
+
+    pub fn push_null(&mut self) -> usize {
+        let id = self.num_rows;
+        for col in self.t_props_log.iter_mut() {
+            col.push_null();
+        }
+        self.num_rows += 1;
+        id
+    }
+
+    pub fn get(&self, prop_id: usize) -> Option<&PropColumn> {
+        self.t_props_log.get(prop_id)
+    }
+
+    pub fn get_mut(&mut self, prop_id: usize) -> Option<&mut PropColumn> {
+        self.t_props_log.get_mut(prop_id)
+    }
+
+    pub fn getx(&self, prop_id: usize) -> Option<&PropColumn> {
         self.t_props_log.get(prop_id)
     }
 
@@ -130,13 +101,29 @@ impl TColumns {
         self.num_rows == 0
     }
 
-    pub fn iter(&self) -> impl Iterator<Item = &TPropColumn> {
+    pub fn iter(&self) -> impl Iterator<Item = &PropColumn> {
         self.t_props_log.iter()
     }
+
+    pub fn num_columns(&self) -> usize {
+        self.t_props_log.len()
+    }
+
+    pub fn reset_len(&mut self) {
+        self.num_rows = self
+            .t_props_log
+            .iter()
+            .map(|col| col.len())
+            .max()
+            .unwrap_or(0);
+        self.t_props_log
+            .iter_mut()
+            .for_each(|col| col.grow(self.num_rows));
+    }
 }
 
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
-pub enum TPropColumn {
+#[derive(Debug)]
+pub enum PropColumn {
     Empty(usize),
     Bool(LazyVec<bool>),
     U8(LazyVec<u8>),
@@ -147,10 +134,8 @@ pub enum TPropColumn {
     I64(LazyVec<i64>),
     F32(LazyVec<f32>),
     F64(LazyVec<f64>),
-    Str(LazyVec<ArcStr>),
-    #[cfg(feature = "arrow")]
-    Array(LazyVec<PropArray>),
-    List(LazyVec<Arc<Vec<Prop>>>),
+    Str(StringCol),
+    List(LazyVec<PropArray>),
     Map(LazyVec<Arc<FxHashMap<ArcStr, Prop>>>),
     NDTime(LazyVec<chrono::NaiveDateTime>),
     DTime(LazyVec<chrono::DateTime<chrono::Utc>>),
@@ -160,75 +145,56 @@ pub enum TPropColumn {
 #[derive(Error, Debug)]
 pub enum TPropColumnError {
     #[error(transparent)]
-    IllegalSetBool(#[from] IllegalSet<bool>),
-    #[error(transparent)]
-    IllegalSetU8(#[from] IllegalSet<u8>),
+    IllegalSet(IllegalSet<Prop>),
     #[error(transparent)]
-    IllegalSetU16(#[from] IllegalSet<u16>),
+    IllegalType(#[from] IllegalPropType),
     #[error(transparent)]
-    IllegalSetU32(#[from] IllegalSet<u32>),
-    #[error(transparent)]
-    IllegalSetU64(#[from] IllegalSet<u64>),
-    #[error(transparent)]
-    IllegalSetI32(#[from] IllegalSet<i32>),
-    #[error(transparent)]
-    IllegalSetI64(#[from] IllegalSet<i64>),
-    #[error(transparent)]
-    IllegalSetF32(#[from] IllegalSet<f32>),
-    #[error(transparent)]
-    IllegalSetF64(#[from] IllegalSet<f64>),
-    #[error(transparent)]
-    IllegalSetStr(#[from] IllegalSet<ArcStr>),
-    #[cfg(feature = "arrow")]
-    #[error(transparent)]
-    IllegalSetArray(#[from] IllegalSet<PropArray>),
-    #[error(transparent)]
-    IllegalSetList(#[from] IllegalSet<Arc<Vec<Prop>>>),
-    #[error(transparent)]
-    IllegalSetMap(#[from] IllegalSet<Arc<FxHashMap<ArcStr, Prop>>>),
-    #[error(transparent)]
-    IllegalSetNDTime(#[from] IllegalSet<chrono::NaiveDateTime>),
-    #[error(transparent)]
-    IllegalSetDTime(#[from] IllegalSet<chrono::DateTime<chrono::Utc>>),
-    #[error(transparent)]
-    Decimal(#[from] IllegalSet<BigDecimal>),
-    #[error(transparent)]
-    IllegalPropType(#[from] IllegalPropType),
+    Arrow(#[from] ArrowError),
+}
+
+impl<A: Into<Prop> + Debug> From<IllegalSet<A>> for TPropColumnError {
+    fn from(value: IllegalSet<A>) -> Self {
+        let previous_value = value.previous_value.into();
+        let new_value = value.new_value.into();
+        TPropColumnError::IllegalSet(IllegalSet {
+            index: value.index,
+            previous_value,
+            new_value,
+        })
+    }
 }
 
-impl Default for TPropColumn {
+impl Default for PropColumn {
     fn default() -> Self {
-        TPropColumn::Empty(0)
+        PropColumn::Empty(0)
     }
 }
 
-impl TPropColumn {
-    pub(crate) fn new(idx: usize, prop: Prop) -> Self {
-        let mut col = TPropColumn::default();
-        col.set(idx, prop).unwrap();
+impl PropColumn {
+    pub(crate) fn new(idx: usize, prop: PropRef<'_>) -> Self {
+        let mut col = PropColumn::default();
+        col.upsert(idx, prop).unwrap();
         col
     }
 
     pub(crate) fn dtype(&self) -> PropType {
         match self {
-            TPropColumn::Empty(_) => PropType::Empty,
-            TPropColumn::Bool(_) => PropType::Bool,
-            TPropColumn::U8(_) => PropType::U8,
-            TPropColumn::U16(_) => PropType::U16,
-            TPropColumn::U32(_) => PropType::U32,
-            TPropColumn::U64(_) => PropType::U64,
-            TPropColumn::I32(_) => PropType::I32,
-            TPropColumn::I64(_) => PropType::I64,
-            TPropColumn::F32(_) => PropType::F32,
-            TPropColumn::F64(_) => PropType::F64,
-            TPropColumn::Str(_) => PropType::Str,
-            #[cfg(feature = "arrow")]
-            TPropColumn::Array(_) => PropType::Array(Box::new(PropType::Empty)),
-            TPropColumn::List(_) => PropType::List(Box::new(PropType::Empty)),
-            TPropColumn::Map(_) => PropType::Map(HashMap::new().into()),
-            TPropColumn::NDTime(_) => PropType::NDTime,
-            TPropColumn::DTime(_) => PropType::DTime,
-            TPropColumn::Decimal(_) => PropType::Decimal { scale: 0 },
+            PropColumn::Empty(_) => PropType::Empty,
+            PropColumn::Bool(_) => PropType::Bool,
+            PropColumn::U8(_) => PropType::U8,
+            PropColumn::U16(_) => PropType::U16,
+            PropColumn::U32(_) => PropType::U32,
+            PropColumn::U64(_) => PropType::U64,
+            PropColumn::I32(_) => PropType::I32,
+            PropColumn::I64(_) => PropType::I64,
+            PropColumn::F32(_) => PropType::F32,
+            PropColumn::F64(_) => PropType::F64,
+            PropColumn::Str(_) => PropType::Str,
+            PropColumn::List(_) => PropType::List(Box::new(PropType::Empty)),
+            PropColumn::Map(_) => PropType::Map(HashMap::new().into()),
+            PropColumn::NDTime(_) => PropType::NDTime,
+            PropColumn::DTime(_) => PropType::DTime,
+            PropColumn::Decimal(_) => PropType::Decimal { scale: 0 },
         }
     }
 
@@ -238,761 +204,249 @@ impl TPropColumn {
         }
     }
 
-    pub(crate) fn set(&mut self, index: usize, prop: Prop) -> Result<(), TPropColumnError> {
+    pub fn upsert(&mut self, index: usize, prop: PropRef<'_>) -> Result<(), TPropColumnError> {
         self.init_empty_col(&prop);
         match (self, prop) {
-            (TPropColumn::Bool(col), Prop::Bool(v)) => col.set(index, v)?,
-            (TPropColumn::I64(col), Prop::I64(v)) => col.set(index, v)?,
-            (TPropColumn::U32(col), Prop::U32(v)) => col.set(index, v)?,
-            (TPropColumn::U64(col), Prop::U64(v)) => col.set(index, v)?,
-            (TPropColumn::F32(col), Prop::F32(v)) => col.set(index, v)?,
-            (TPropColumn::F64(col), Prop::F64(v)) => col.set(index, v)?,
-            (TPropColumn::Str(col), Prop::Str(v)) => col.set(index, v)?,
-            #[cfg(feature = "arrow")]
-            (TPropColumn::Array(col), Prop::Array(v)) => col.set(index, v)?,
-            (TPropColumn::U8(col), Prop::U8(v)) => col.set(index, v)?,
-            (TPropColumn::U16(col), Prop::U16(v)) => col.set(index, v)?,
-            (TPropColumn::I32(col), Prop::I32(v)) => col.set(index, v)?,
-            (TPropColumn::List(col), Prop::List(v)) => col.set(index, v)?,
-            (TPropColumn::Map(col), Prop::Map(v)) => col.set(index, v)?,
-            (TPropColumn::NDTime(col), Prop::NDTime(v)) => col.set(index, v)?,
-            (TPropColumn::DTime(col), Prop::DTime(v)) => col.set(index, v)?,
-            (TPropColumn::Decimal(col), Prop::Decimal(v)) => col.set(index, v)?,
+            (PropColumn::Bool(col), PropRef::Bool(v)) => col.upsert(index, v),
+            (PropColumn::I64(col), PropRef::Num(PropNum::I64(v))) => col.upsert(index, v),
+            (PropColumn::U32(col), PropRef::Num(PropNum::U32(v))) => col.upsert(index, v),
+            (PropColumn::U64(col), PropRef::Num(PropNum::U64(v))) => col.upsert(index, v),
+            (PropColumn::F32(col), PropRef::Num(PropNum::F32(v))) => col.upsert(index, v),
+            (PropColumn::F64(col), PropRef::Num(PropNum::F64(v))) => col.upsert(index, v),
+            (PropColumn::Str(col), PropRef::Str(v)) => col.upsert(index, v)?,
+            (PropColumn::U8(col), PropRef::Num(PropNum::U8(v))) => col.upsert(index, v),
+            (PropColumn::U16(col), PropRef::Num(PropNum::U16(v))) => col.upsert(index, v),
+            (PropColumn::I32(col), PropRef::Num(PropNum::I32(v))) => col.upsert(index, v),
+            (PropColumn::List(col), PropRef::List(v)) => col.upsert(index, v.into_owned()),
+            (PropColumn::Map(col), PropRef::Map(v)) => match v {
+                PropMapRef::Mem(map) => col.upsert(index, map.clone()),
+                PropMapRef::PropCol { map, i } => {
+                    if let Some(entry) = map.get(i).and_then(|prop| prop.into_map()) {
+                        col.upsert(index, entry);
+                    }
+                }
+                PropMapRef::Arrow(arc_map) => {
+                    if let Some(prop) = arc_map.into_prop() {
+                        if let Some(map_ref) = prop.as_prop_ref().as_map_ref() {
+                            if let Some(map) = map_ref.as_map() {
+                                col.upsert(index, map.clone());
+                            }
+                        }
+                    }
+                }
+            },
+            (PropColumn::NDTime(col), PropRef::NDTime(v)) => col.upsert(index, v),
+            (PropColumn::DTime(col), PropRef::DTime(v)) => col.upsert(index, v),
+            (PropColumn::Decimal(col), PropRef::Decimal { num, scale }) => {
+                col.upsert(index, BigDecimal::from_bigint(num.into(), scale as i64))
+            }
             (col, prop) => {
                 Err(IllegalPropType {
                     expected: col.dtype(),
-                    actual: prop.dtype(),
+                    actual: prop.into_prop().dtype(),
                 })?;
             }
         }
         Ok(())
     }
 
-    pub(crate) fn push(&mut self, prop: Prop) -> Result<(), IllegalPropType> {
-        self.init_empty_col(&prop);
+    pub fn check(&self, index: usize, prop: &PropRef<'_>) -> Result<(), TPropColumnError> {
         match (self, prop) {
-            (TPropColumn::Bool(col), Prop::Bool(v)) => col.push(Some(v)),
-            (TPropColumn::U8(col), Prop::U8(v)) => col.push(Some(v)),
-            (TPropColumn::I64(col), Prop::I64(v)) => col.push(Some(v)),
-            (TPropColumn::U32(col), Prop::U32(v)) => col.push(Some(v)),
-            (TPropColumn::U64(col), Prop::U64(v)) => col.push(Some(v)),
-            (TPropColumn::F32(col), Prop::F32(v)) => col.push(Some(v)),
-            (TPropColumn::F64(col), Prop::F64(v)) => col.push(Some(v)),
-            (TPropColumn::Str(col), Prop::Str(v)) => col.push(Some(v)),
-            #[cfg(feature = "arrow")]
-            (TPropColumn::Array(col), Prop::Array(v)) => col.push(Some(v)),
-            (TPropColumn::U16(col), Prop::U16(v)) => col.push(Some(v)),
-            (TPropColumn::I32(col), Prop::I32(v)) => col.push(Some(v)),
-            (TPropColumn::List(col), Prop::List(v)) => col.push(Some(v)),
-            (TPropColumn::Map(col), Prop::Map(v)) => col.push(Some(v)),
-            (TPropColumn::NDTime(col), Prop::NDTime(v)) => col.push(Some(v)),
-            (TPropColumn::DTime(col), Prop::DTime(v)) => col.push(Some(v)),
-            (TPropColumn::Decimal(col), Prop::Decimal(v)) => col.push(Some(v)),
+            (PropColumn::Empty(_), _) => {}
+            (PropColumn::Bool(col), PropRef::Bool(v)) => col.check(index, v)?,
+            (PropColumn::I64(col), PropRef::Num(PropNum::I64(v))) => col.check(index, v)?,
+            (PropColumn::U32(col), PropRef::Num(PropNum::U32(v))) => col.check(index, v)?,
+            (PropColumn::U64(col), PropRef::Num(PropNum::U64(v))) => col.check(index, v)?,
+            (PropColumn::F32(col), PropRef::Num(PropNum::F32(v))) => col.check(index, v)?,
+            (PropColumn::F64(col), PropRef::Num(PropNum::F64(v))) => col.check(index, v)?,
+            (PropColumn::Str(col), PropRef::Str(v)) => col.check(index, v)?,
+            (PropColumn::U8(col), PropRef::Num(PropNum::U8(v))) => col.check(index, v)?,
+            (PropColumn::U16(col), PropRef::Num(PropNum::U16(v))) => col.check(index, v)?,
+            (PropColumn::I32(col), PropRef::Num(PropNum::I32(v))) => col.check(index, v)?,
+            (PropColumn::List(col), PropRef::List(v)) => col.check(index, v)?,
+            (PropColumn::Map(col), PropRef::Map(v)) => col.check(index, &v.as_mem())?,
+            (PropColumn::NDTime(col), PropRef::NDTime(v)) => col.check(index, v)?,
+            (PropColumn::DTime(col), PropRef::DTime(v)) => col.check(index, v)?,
+            (PropColumn::Decimal(col), PropRef::Decimal { num, scale }) => col.check(
+                index,
+                &BigDecimal::from_bigint(BigInt::from(*num), *scale as i64),
+            )?,
             (col, prop) => {
-                return Err(IllegalPropType {
+                Err(IllegalPropType {
                     expected: col.dtype(),
-                    actual: prop.dtype(),
-                })
+                    actual: prop.clone().into_prop().dtype(),
+                })?;
             }
         }
         Ok(())
     }
 
-    fn init_empty_col(&mut self, prop: &Prop) {
-        if let TPropColumn::Empty(len) = self {
-            match prop {
-                Prop::Bool(_) => *self = TPropColumn::Bool(LazyVec::with_len(*len)),
-                Prop::I64(_) => *self = TPropColumn::I64(LazyVec::with_len(*len)),
-                Prop::U32(_) => *self = TPropColumn::U32(LazyVec::with_len(*len)),
-                Prop::U64(_) => *self = TPropColumn::U64(LazyVec::with_len(*len)),
-                Prop::F32(_) => *self = TPropColumn::F32(LazyVec::with_len(*len)),
-                Prop::F64(_) => *self = TPropColumn::F64(LazyVec::with_len(*len)),
-                Prop::Str(_) => *self = TPropColumn::Str(LazyVec::with_len(*len)),
-                #[cfg(feature = "arrow")]
-                Prop::Array(_) => *self = TPropColumn::Array(LazyVec::with_len(*len)),
-                Prop::U8(_) => *self = TPropColumn::U8(LazyVec::with_len(*len)),
-                Prop::U16(_) => *self = TPropColumn::U16(LazyVec::with_len(*len)),
-                Prop::I32(_) => *self = TPropColumn::I32(LazyVec::with_len(*len)),
-                Prop::List(_) => *self = TPropColumn::List(LazyVec::with_len(*len)),
-                Prop::Map(_) => *self = TPropColumn::Map(LazyVec::with_len(*len)),
-                Prop::NDTime(_) => *self = TPropColumn::NDTime(LazyVec::with_len(*len)),
-                Prop::DTime(_) => *self = TPropColumn::DTime(LazyVec::with_len(*len)),
-                Prop::Decimal(_) => *self = TPropColumn::Decimal(LazyVec::with_len(*len)),
-            }
-        }
-    }
-
-    fn is_empty(&self) -> bool {
-        matches!(self, TPropColumn::Empty(_))
-    }
-
-    pub(crate) fn push_null(&mut self) {
-        match self {
-            TPropColumn::Bool(col) => col.push(None),
-            TPropColumn::I64(col) => col.push(None),
-            TPropColumn::U32(col) => col.push(None),
-            TPropColumn::U64(col) => col.push(None),
-            TPropColumn::F32(col) => col.push(None),
-            TPropColumn::F64(col) => col.push(None),
-            TPropColumn::Str(col) => col.push(None),
-            #[cfg(feature = "arrow")]
-            TPropColumn::Array(col) => col.push(None),
-            TPropColumn::U8(col) => col.push(None),
-            TPropColumn::U16(col) => col.push(None),
-            TPropColumn::I32(col) => col.push(None),
-            TPropColumn::List(col) => col.push(None),
-            TPropColumn::Map(col) => col.push(None),
-            TPropColumn::NDTime(col) => col.push(None),
-            TPropColumn::DTime(col) => col.push(None),
-            TPropColumn::Decimal(col) => col.push(None),
-            TPropColumn::Empty(count) => {
-                *count += 1;
-            }
-        }
-    }
-
-    pub fn get(&self, index: usize) -> Option<Prop> {
-        match self {
-            TPropColumn::Bool(col) => col.get_opt(index).map(|prop| (*prop).into()),
-            TPropColumn::I64(col) => col.get_opt(index).map(|prop| (*prop).into()),
-            TPropColumn::U32(col) => col.get_opt(index).map(|prop| (*prop).into()),
-            TPropColumn::U64(col) => col.get_opt(index).map(|prop| (*prop).into()),
-            TPropColumn::F32(col) => col.get_opt(index).map(|prop| (*prop).into()),
-            TPropColumn::F64(col) => col.get_opt(index).map(|prop| (*prop).into()),
-            TPropColumn::Str(col) => col.get_opt(index).map(|prop| prop.into()),
-            #[cfg(feature = "arrow")]
-            TPropColumn::Array(col) => col.get_opt(index).map(|prop| Prop::Array(prop.clone())),
-            TPropColumn::U8(col) => col.get_opt(index).map(|prop| (*prop).into()),
-            TPropColumn::U16(col) => col.get_opt(index).map(|prop| (*prop).into()),
-            TPropColumn::I32(col) => col.get_opt(index).map(|prop| (*prop).into()),
-            TPropColumn::List(col) => col.get_opt(index).map(|prop| Prop::List(prop.clone())),
-            TPropColumn::Map(col) => col.get_opt(index).map(|prop| Prop::Map(prop.clone())),
-            TPropColumn::NDTime(col) => col.get_opt(index).map(|prop| Prop::NDTime(*prop)),
-            TPropColumn::DTime(col) => col.get_opt(index).map(|prop| Prop::DTime(*prop)),
-            TPropColumn::Decimal(col) => col.get_opt(index).map(|prop| Prop::Decimal(prop.clone())),
-            TPropColumn::Empty(_) => None,
-        }
-    }
-
-    pub(crate) fn len(&self) -> usize {
-        match self {
-            TPropColumn::Bool(col) => col.len(),
-            TPropColumn::I64(col) => col.len(),
-            TPropColumn::U32(col) => col.len(),
-            TPropColumn::U64(col) => col.len(),
-            TPropColumn::F32(col) => col.len(),
-            TPropColumn::F64(col) => col.len(),
-            TPropColumn::Str(col) => col.len(),
-            #[cfg(feature = "arrow")]
-            TPropColumn::Array(col) => col.len(),
-            TPropColumn::U8(col) => col.len(),
-            TPropColumn::U16(col) => col.len(),
-            TPropColumn::I32(col) => col.len(),
-            TPropColumn::List(col) => col.len(),
-            TPropColumn::Map(col) => col.len(),
-            TPropColumn::NDTime(col) => col.len(),
-            TPropColumn::DTime(col) => col.len(),
-            TPropColumn::Decimal(col) => col.len(),
-            TPropColumn::Empty(count) => *count,
-        }
-    }
-}
-
-impl NodeSlot {
-    pub fn t_props_log(&self) -> &TColumns {
-        &self.t_props_log
-    }
-
-    pub fn t_props_log_mut(&mut self) -> &mut TColumns {
-        &mut self.t_props_log
-    }
-
-    pub fn iter(&self) -> impl Iterator<Item = NodePtr<'_>> {
-        self.nodes
-            .iter()
-            .filter(|v| v.is_initialised())
-            .map(|ns| NodePtr::new(ns, &self.t_props_log))
-    }
-
-    pub fn par_iter(&self) -> impl ParallelIterator<Item = NodePtr<'_>> {
-        self.nodes
-            .par_iter()
-            .filter(|v| v.is_initialised())
-            .map(|ns| NodePtr::new(ns, &self.t_props_log))
-    }
-}
-
-impl Index<usize> for NodeSlot {
-    type Output = NodeStore;
-
-    fn index(&self, index: usize) -> &Self::Output {
-        &self.nodes[index]
-    }
-}
-
-impl IndexMut<usize> for NodeSlot {
-    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
-        &mut self.nodes[index]
-    }
-}
-
-impl Deref for NodeSlot {
-    type Target = Vec<NodeStore>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.nodes
-    }
-}
-
-impl DerefMut for NodeSlot {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.nodes
-    }
-}
-
-impl PartialEq for NodeVec {
-    fn eq(&self, other: &Self) -> bool {
-        let a = self.data.read_recursive();
-        let b = other.data.read_recursive();
-        a.deref() == b.deref()
-    }
-}
-
-impl Default for NodeVec {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl NodeVec {
-    pub fn new() -> Self {
-        Self {
-            data: Arc::new(RwLock::new(Default::default())),
-        }
-    }
-
-    #[inline]
-    pub fn read_arc_lock(&self) -> ArcRwLockReadGuard<NodeSlot> {
-        RwLock::read_arc_recursive(&self.data)
-    }
-
-    #[inline]
-    pub fn write(&self) -> impl DerefMut<Target = NodeSlot> + '_ {
-        loop_lock_write(&self.data)
-    }
-
-    #[inline]
-    pub fn read(&self) -> impl Deref<Target = NodeSlot> + '_ {
-        self.data.read_recursive()
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct NodeStorage {
-    pub(crate) data: Box<[NodeVec]>,
-    len: AtomicUsize,
-}
-
-impl Debug for NodeStorage {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("NodeStorage")
-            .field("len", &self.len())
-            .field("data", &self.read_lock().iter().collect_vec())
-            .finish()
-    }
-}
-
-impl PartialEq for NodeStorage {
-    fn eq(&self, other: &Self) -> bool {
-        self.data.eq(&other.data)
-    }
-}
-
-#[derive(Debug)]
-pub struct ReadLockedStorage {
-    pub(crate) locks: Vec<Arc<ArcRwLockReadGuard<NodeSlot>>>,
-    len: usize,
-}
-
-impl ReadLockedStorage {
-    fn resolve(&self, index: VID) -> (usize, usize) {
-        let index: usize = index.into();
-        let n = self.locks.len();
-        let bucket = index % n;
-        let offset = index / n;
-        (bucket, offset)
-    }
-
-    pub fn len(&self) -> usize {
-        self.len
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.len == 0
-    }
-
-    #[cfg(test)]
-    pub fn get(&self, index: VID) -> &NodeStore {
-        let (bucket, offset) = self.resolve(index);
-        let bucket = &self.locks[bucket];
-        &bucket[offset]
-    }
-
-    #[inline]
-    pub fn get_entry(&self, index: VID) -> NodePtr<'_> {
-        let (bucket, offset) = self.resolve(index);
-        let bucket = &self.locks[bucket];
-        NodePtr::new(&bucket[offset], &bucket.t_props_log)
-    }
-
-    #[inline]
-    pub fn try_get_entry(&self, index: VID) -> Option<NodePtr<'_>> {
-        let (bucket, offset) = self.resolve(index);
-        let bucket = self.locks.get(bucket)?;
-        let node = bucket.get(offset)?;
-        if node.is_initialised() {
-            Some(NodePtr::new(node, &bucket.t_props_log))
-        } else {
-            None
-        }
-    }
-
-    pub fn iter(&self) -> impl Iterator<Item = NodePtr<'_>> + '_ {
-        self.locks.iter().flat_map(|v| v.iter())
-    }
-
-    pub fn par_iter(&self) -> impl ParallelIterator<Item = NodePtr<'_>> + '_ {
-        self.locks.par_iter().flat_map(|v| v.par_iter())
-    }
-}
-
-impl NodeStorage {
-    pub fn count_with_filter<F: Fn(NodePtr<'_>) -> bool + Send + Sync>(&self, f: F) -> usize {
-        self.read_lock().par_iter().filter(|x| f(*x)).count()
-    }
-}
-
-impl NodeStorage {
-    #[inline]
-    fn resolve(&self, index: usize) -> (usize, usize) {
-        resolve(index, self.data.len())
-    }
-
-    #[inline]
-    pub fn read_lock(&self) -> ReadLockedStorage {
-        let guards = self
-            .data
-            .iter()
-            .map(|v| Arc::new(v.read_arc_lock()))
-            .collect();
-        ReadLockedStorage {
-            locks: guards,
-            len: self.len(),
-        }
-    }
-
-    pub fn write_lock(&self) -> WriteLockedNodes<'_> {
-        WriteLockedNodes {
-            guards: self.data.iter().map(|lock| lock.data.write()).collect(),
-            global_len: &self.len,
-        }
-    }
-
-    pub fn new(n_locks: usize) -> Self {
-        let data: Box<[NodeVec]> = (0..n_locks)
-            .map(|_| NodeVec::new())
-            .collect::<Vec<_>>()
-            .into();
-
-        Self {
-            data,
-            len: AtomicUsize::new(0),
-        }
-    }
-
-    pub fn push(&self, mut value: NodeStore) -> UninitialisedEntry<'_, NodeStore, NodeSlot> {
-        let index = self.len.fetch_add(1, Ordering::Relaxed);
-        value.vid = VID(index);
-        let (bucket, offset) = self.resolve(index);
-        let guard = loop_lock_write(&self.data[bucket].data);
-        UninitialisedEntry {
-            offset,
-            guard,
-            value,
-        }
-    }
-
-    pub fn set(&self, value: NodeStore) {
-        let VID(index) = value.vid;
-        self.len.fetch_max(index + 1, Ordering::Relaxed);
-        let (bucket, offset) = self.resolve(index);
-        let mut guard = loop_lock_write(&self.data[bucket].data);
-        if guard.len() <= offset {
-            guard.resize_with(offset + 1, NodeStore::default)
-        }
-        guard[offset] = value
-    }
-
-    #[inline]
-    pub fn entry(&self, index: VID) -> NodeEntry<'_> {
-        let index = index.into();
-        let (bucket, offset) = self.resolve(index);
-        let guard = self.data[bucket].data.read_recursive();
-        NodeEntry { offset, guard }
-    }
-
-    /// Get the node if it is initialised
-    pub fn try_entry(&self, index: VID) -> Option<NodeEntry<'_>> {
-        let (bucket, offset) = self.resolve(index.index());
-        let guard = self.data.get(bucket)?.data.read_recursive();
-        if guard.get(offset)?.is_initialised() {
-            Some(NodeEntry { offset, guard })
-        } else {
-            None
-        }
-    }
-
-    pub fn entry_mut(&self, index: VID) -> EntryMut<'_, RwLockWriteGuard<'_, NodeSlot>> {
-        let index = index.into();
-        let (bucket, offset) = self.resolve(index);
-        let guard = loop_lock_write(&self.data[bucket].data);
-        EntryMut {
-            i: offset,
-            guard,
-            _pd: PhantomData,
-        }
-    }
-
-    pub fn prop_entry_mut(&self, index: VID) -> impl DerefMut<Target = TColumns> + '_ {
-        let index = index.into();
-        let (bucket, _) = self.resolve(index);
-        let lock = loop_lock_write(&self.data[bucket].data);
-        RwLockWriteGuard::map(lock, |data| &mut data.t_props_log)
-    }
-
-    // This helps get the right locks when adding an edge
-    #[deprecated(note = "use loop_pair_entry_mut instead")]
-    pub fn pair_entry_mut(&self, i: VID, j: VID) -> PairEntryMut<'_> {
-        let i = i.into();
-        let j = j.into();
-        let (bucket_i, offset_i) = self.resolve(i);
-        let (bucket_j, offset_j) = self.resolve(j);
-        // always acquire lock for smaller bucket first to avoid deadlock between two updates for the same pair of buckets
-        if bucket_i < bucket_j {
-            let guard_i = self.data[bucket_i].data.write();
-            let guard_j = self.data[bucket_j].data.write();
-            PairEntryMut::Different {
-                i: offset_i,
-                j: offset_j,
-                guard1: guard_i,
-                guard2: guard_j,
+    pub(crate) fn push(&mut self, prop: PropRef<'_>) -> Result<(), TPropColumnError> {
+        self.init_empty_col(&prop);
+        match (self, prop) {
+            (PropColumn::Bool(col), PropRef::Bool(v)) => col.push(Some(v)),
+            (PropColumn::U8(col), PropRef::Num(PropNum::U8(v))) => col.push(Some(v)),
+            (PropColumn::I64(col), PropRef::Num(PropNum::I64(v))) => col.push(Some(v)),
+            (PropColumn::U32(col), PropRef::Num(PropNum::U32(v))) => col.push(Some(v)),
+            (PropColumn::U64(col), PropRef::Num(PropNum::U64(v))) => col.push(Some(v)),
+            (PropColumn::F32(col), PropRef::Num(PropNum::F32(v))) => col.push(Some(v)),
+            (PropColumn::F64(col), PropRef::Num(PropNum::F64(v))) => col.push(Some(v)),
+            (PropColumn::Str(col), PropRef::Str(v)) => col.push_value(v)?,
+            (PropColumn::U16(col), PropRef::Num(PropNum::U16(v))) => col.push(Some(v)),
+            (PropColumn::I32(col), PropRef::Num(PropNum::I32(v))) => col.push(Some(v)),
+            (PropColumn::List(col), PropRef::List(v)) => col.push(Some(v.into_owned())),
+            (PropColumn::Map(col), PropRef::Map(v)) => {
+                // FIXME: if we start bulk loading complex structs this won't do
+                match v {
+                    PropMapRef::Mem(map) => col.push(Some(map.clone())),
+                    PropMapRef::PropCol { map, i } => {
+                        col.push(map.get(i).and_then(|prop| prop.into_map()))
+                    }
+                    PropMapRef::Arrow(arc_map) => {
+                        if let Some(prop) = arc_map.into_prop() {
+                            if let Some(map_ref) = prop.as_prop_ref().as_map_ref() {
+                                if let Some(map) = map_ref.as_map() {
+                                    col.push(Some(map.clone()));
+                                }
+                            }
+                        }
+                    }
+                }
             }
-        } else if bucket_i > bucket_j {
-            let guard_j = self.data[bucket_j].data.write();
-            let guard_i = self.data[bucket_i].data.write();
-            PairEntryMut::Different {
-                i: offset_i,
-                j: offset_j,
-                guard1: guard_i,
-                guard2: guard_j,
+            (PropColumn::NDTime(col), PropRef::NDTime(v)) => col.push(Some(v)),
+            (PropColumn::DTime(col), PropRef::DTime(v)) => col.push(Some(v)),
+            (PropColumn::Decimal(col), PropRef::Decimal { num, scale }) => {
+                col.push(Some(BigDecimal::from_bigint(num.into(), scale as i64)))
             }
-        } else {
-            PairEntryMut::Same {
-                i: offset_i,
-                j: offset_j,
-                guard: self.data[bucket_i].data.write(),
+            (col, prop) => {
+                Err(IllegalPropType {
+                    expected: col.dtype(),
+                    actual: prop.into_prop().dtype(),
+                })?;
             }
         }
+        Ok(())
     }
 
-    pub fn loop_pair_entry_mut(&self, i: VID, j: VID) -> PairEntryMut<'_> {
-        let i = i.into();
-        let j = j.into();
-        let (bucket_i, offset_i) = self.resolve(i);
-        let (bucket_j, offset_j) = self.resolve(j);
-        loop {
-            if bucket_i < bucket_j {
-                let guard_i = self.data[bucket_i].data.try_write();
-                let guard_j = self.data[bucket_j].data.try_write();
-                let maybe_guards =
-                    guard_i
-                        .zip(guard_j)
-                        .map(|(guard_i, guard_j)| PairEntryMut::Different {
-                            i: offset_i,
-                            j: offset_j,
-                            guard1: guard_i,
-                            guard2: guard_j,
-                        });
-                if let Some(guards) = maybe_guards {
-                    return guards;
-                }
-            } else if bucket_i > bucket_j {
-                let guard_j = self.data[bucket_j].data.try_write();
-                let guard_i = self.data[bucket_i].data.try_write();
-                let maybe_guards =
-                    guard_i
-                        .zip(guard_j)
-                        .map(|(guard_i, guard_j)| PairEntryMut::Different {
-                            i: offset_i,
-                            j: offset_j,
-                            guard1: guard_i,
-                            guard2: guard_j,
-                        });
-                if let Some(guards) = maybe_guards {
-                    return guards;
-                }
-            } else {
-                let maybe_guard = self.data[bucket_i].data.try_write();
-                if let Some(guard) = maybe_guard {
-                    return PairEntryMut::Same {
-                        i: offset_i,
-                        j: offset_j,
-                        guard,
-                    };
-                }
+    fn init_empty_col(&mut self, prop: &PropRef<'_>) {
+        if let PropColumn::Empty(len) = self {
+            match prop {
+                PropRef::Bool(_) => *self = PropColumn::Bool(LazyVec::with_len(*len)),
+                PropRef::Num(PropNum::I64(_)) => *self = PropColumn::I64(LazyVec::with_len(*len)),
+                PropRef::Num(PropNum::U32(_)) => *self = PropColumn::U32(LazyVec::with_len(*len)),
+                PropRef::Num(PropNum::U64(_)) => *self = PropColumn::U64(LazyVec::with_len(*len)),
+                PropRef::Num(PropNum::F32(_)) => *self = PropColumn::F32(LazyVec::with_len(*len)),
+                PropRef::Num(PropNum::F64(_)) => *self = PropColumn::F64(LazyVec::with_len(*len)),
+                PropRef::Str(_) => *self = PropColumn::Str(StringCol::with_len(*len)),
+                PropRef::Num(PropNum::U8(_)) => *self = PropColumn::U8(LazyVec::with_len(*len)),
+                PropRef::Num(PropNum::U16(_)) => *self = PropColumn::U16(LazyVec::with_len(*len)),
+                PropRef::Num(PropNum::I32(_)) => *self = PropColumn::I32(LazyVec::with_len(*len)),
+                PropRef::List(_) => *self = PropColumn::List(LazyVec::with_len(*len)),
+                PropRef::Map(_) => *self = PropColumn::Map(LazyVec::with_len(*len)),
+                PropRef::NDTime(_) => *self = PropColumn::NDTime(LazyVec::with_len(*len)),
+                PropRef::DTime(_) => *self = PropColumn::DTime(LazyVec::with_len(*len)),
+                PropRef::Decimal { .. } => *self = PropColumn::Decimal(LazyVec::with_len(*len)),
             }
         }
     }
 
-    #[inline]
-    pub fn len(&self) -> usize {
-        self.len.load(Ordering::SeqCst)
-    }
-
     pub fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-
-    pub fn next_id(&self) -> VID {
-        VID(self.len.fetch_add(1, Ordering::Relaxed))
-    }
-}
-
-pub struct WriteLockedNodes<'a> {
-    guards: Vec<RwLockWriteGuard<'a, NodeSlot>>,
-    global_len: &'a AtomicUsize,
-}
-
-pub struct NodeShardWriter<'a, S> {
-    shard: S,
-    shard_id: usize,
-    num_shards: usize,
-    global_len: &'a AtomicUsize,
-}
-
-impl<'a, S> NodeShardWriter<'a, S>
-where
-    S: DerefMut<Target = NodeSlot>,
-{
-    #[inline]
-    fn resolve(&self, index: VID) -> Option<usize> {
-        let (shard_id, offset) = resolve(index.into(), self.num_shards);
-        (shard_id == self.shard_id).then_some(offset)
-    }
-
-    #[inline]
-    pub fn get_mut(&mut self, index: VID) -> Option<&mut NodeStore> {
-        self.resolve(index).map(|offset| &mut self.shard[offset])
-    }
-
-    #[inline]
-    pub fn get_mut_entry(&mut self, index: VID) -> Option<EntryMut<'_, &mut S>> {
-        self.resolve(index).map(|offset| EntryMut {
-            i: offset,
-            guard: &mut self.shard,
-            _pd: PhantomData,
-        })
-    }
-
-    #[inline]
-    pub fn get(&self, index: VID) -> Option<&NodeStore> {
-        self.resolve(index).map(|offset| &self.shard[offset])
-    }
-
-    #[inline]
-    pub fn t_prop_log_mut(&mut self) -> &mut TColumns {
-        &mut self.shard.t_props_log
+        matches!(self, PropColumn::Empty(_))
     }
 
-    pub fn set(&mut self, vid: VID, gid: GidRef) -> Option<EntryMut<'_, &mut S>> {
-        self.resolve(vid).map(|offset| {
-            if offset >= self.shard.len() {
-                self.shard.resize_with(offset + 1, NodeStore::default);
-                self.global_len
-                    .fetch_max(vid.index() + 1, Ordering::Relaxed);
-            }
-            self.shard[offset] = NodeStore::resolved(gid.to_owned(), vid);
-
-            EntryMut {
-                i: offset,
-                guard: &mut self.shard,
-                _pd: PhantomData,
+    pub(crate) fn push_null(&mut self) {
+        match self {
+            PropColumn::Bool(col) => col.push(None),
+            PropColumn::I64(col) => col.push(None),
+            PropColumn::U32(col) => col.push(None),
+            PropColumn::U64(col) => col.push(None),
+            PropColumn::F32(col) => col.push(None),
+            PropColumn::F64(col) => col.push(None),
+            PropColumn::Str(col) => col.push_null(),
+            PropColumn::U8(col) => col.push(None),
+            PropColumn::U16(col) => col.push(None),
+            PropColumn::I32(col) => col.push(None),
+            PropColumn::List(col) => col.push(None),
+            PropColumn::Map(col) => col.push(None),
+            PropColumn::NDTime(col) => col.push(None),
+            PropColumn::DTime(col) => col.push(None),
+            PropColumn::Decimal(col) => col.push(None),
+            PropColumn::Empty(count) => {
+                *count += 1;
             }
-        })
-    }
-
-    pub fn shard_id(&self) -> usize {
-        self.shard_id
-    }
-
-    fn resize(&mut self, new_global_len: usize) {
-        let mut new_len = new_global_len / self.num_shards;
-        if self.shard_id < new_global_len % self.num_shards {
-            new_len += 1;
         }
-        if new_len > self.shard.len() {
-            self.shard.resize_with(new_len, Default::default);
-            self.global_len.fetch_max(new_global_len, Ordering::Relaxed);
-        }
-    }
-}
-
-impl<'a> WriteLockedNodes<'a> {
-    pub fn par_iter_mut(
-        &mut self,
-    ) -> impl IndexedParallelIterator<Item = NodeShardWriter<'_, &mut NodeSlot>> + '_ {
-        let num_shards = self.guards.len();
-        let global_len = self.global_len;
-        let shards: Vec<&mut NodeSlot> = self
-            .guards
-            .iter_mut()
-            .map(|guard| guard.deref_mut())
-            .collect();
-        shards
-            .into_par_iter()
-            .enumerate()
-            .map(move |(shard_id, shard)| NodeShardWriter {
-                shard,
-                shard_id,
-                num_shards,
-                global_len,
-            })
-    }
-
-    pub fn into_par_iter_mut(
-        self,
-    ) -> impl IndexedParallelIterator<Item = NodeShardWriter<'a, RwLockWriteGuard<'a, NodeSlot>>> + 'a
-    {
-        let num_shards = self.guards.len();
-        let global_len = self.global_len;
-        self.guards
-            .into_par_iter()
-            .enumerate()
-            .map(move |(shard_id, shard)| NodeShardWriter {
-                shard,
-                shard_id,
-                num_shards,
-                global_len,
-            })
-    }
-
-    pub fn resize(&mut self, new_len: usize) {
-        self.par_iter_mut()
-            .for_each(|mut shard| shard.resize(new_len))
     }
 
-    pub fn num_shards(&self) -> usize {
-        self.guards.len()
-    }
-}
-
-#[derive(Debug)]
-pub struct NodeEntry<'a> {
-    offset: usize,
-    guard: RwLockReadGuard<'a, NodeSlot>,
-}
-
-impl NodeEntry<'_> {
-    #[inline]
-    pub fn as_ref(&self) -> NodePtr<'_> {
-        NodePtr::new(&self.guard[self.offset], &self.guard.t_props_log)
-    }
-}
-
-pub enum PairEntryMut<'a> {
-    Same {
-        i: usize,
-        j: usize,
-        guard: parking_lot::RwLockWriteGuard<'a, NodeSlot>,
-    },
-    Different {
-        i: usize,
-        j: usize,
-        guard1: parking_lot::RwLockWriteGuard<'a, NodeSlot>,
-        guard2: parking_lot::RwLockWriteGuard<'a, NodeSlot>,
-    },
-}
-
-impl<'a> PairEntryMut<'a> {
-    pub(crate) fn get_i(&self) -> &NodeStore {
-        match self {
-            PairEntryMut::Same { i, guard, .. } => &guard[*i],
-            PairEntryMut::Different { i, guard1, .. } => &guard1[*i],
-        }
-    }
-    pub(crate) fn get_mut_i(&mut self) -> &mut NodeStore {
+    pub fn get(&self, index: usize) -> Option<Prop> {
         match self {
-            PairEntryMut::Same { i, guard, .. } => &mut guard[*i],
-            PairEntryMut::Different { i, guard1, .. } => &mut guard1[*i],
-        }
-    }
-
-    pub(crate) fn get_j(&self) -> &NodeStore {
+            PropColumn::Bool(col) => col.get_opt(index).map(|prop| (*prop).into()),
+            PropColumn::I64(col) => col.get_opt(index).map(|prop| (*prop).into()),
+            PropColumn::U32(col) => col.get_opt(index).map(|prop| (*prop).into()),
+            PropColumn::U64(col) => col.get_opt(index).map(|prop| (*prop).into()),
+            PropColumn::F32(col) => col.get_opt(index).map(|prop| (*prop).into()),
+            PropColumn::F64(col) => col.get_opt(index).map(|prop| (*prop).into()),
+            PropColumn::Str(col) => col.get_opt(index).map(|prop| prop.into()),
+            PropColumn::U8(col) => col.get_opt(index).map(|prop| (*prop).into()),
+            PropColumn::U16(col) => col.get_opt(index).map(|prop| (*prop).into()),
+            PropColumn::I32(col) => col.get_opt(index).map(|prop| (*prop).into()),
+            PropColumn::List(col) => col.get_opt(index).map(|prop| Prop::List(prop.clone())),
+            PropColumn::Map(col) => col.get_opt(index).map(|prop| Prop::Map(prop.clone())),
+            PropColumn::NDTime(col) => col.get_opt(index).map(|prop| Prop::NDTime(*prop)),
+            PropColumn::DTime(col) => col.get_opt(index).map(|prop| Prop::DTime(*prop)),
+            PropColumn::Decimal(col) => col.get_opt(index).map(|prop| Prop::Decimal(prop.clone())),
+            PropColumn::Empty(_) => None,
+        }
+    }
+
+    pub fn get_ref(&self, index: usize) -> Option<PropRef<'_>> {
         match self {
-            PairEntryMut::Same { j, guard, .. } => &guard[*j],
-            PairEntryMut::Different { j, guard2, .. } => &guard2[*j],
+            PropColumn::Bool(col) => col.get_opt(index).map(|prop| PropRef::Bool(*prop)),
+            PropColumn::I64(col) => col.get_opt(index).map(|prop| PropRef::from(*prop)),
+            PropColumn::U32(col) => col.get_opt(index).map(|prop| PropRef::from(*prop)),
+            PropColumn::U64(col) => col.get_opt(index).map(|prop| PropRef::from(*prop)),
+            PropColumn::F32(col) => col.get_opt(index).map(|prop| PropRef::from(*prop)),
+            PropColumn::F64(col) => col.get_opt(index).map(|prop| PropRef::from(*prop)),
+            PropColumn::Str(col) => col.get_opt(index).map(|prop| PropRef::Str(prop.as_ref())),
+            PropColumn::U8(col) => col.get_opt(index).map(|prop| PropRef::from(*prop)),
+            PropColumn::U16(col) => col.get_opt(index).map(|prop| PropRef::from(*prop)),
+            PropColumn::I32(col) => col.get_opt(index).map(|prop| PropRef::from(*prop)),
+            PropColumn::List(col) => col
+                .get_opt(index)
+                .map(|prop| PropRef::List(Cow::Borrowed(prop))),
+            PropColumn::Map(col) => col.get_opt(index).map(PropRef::from),
+            PropColumn::NDTime(col) => col.get_opt(index).copied().map(PropRef::from),
+            PropColumn::DTime(col) => col.get_opt(index).copied().map(PropRef::from),
+            PropColumn::Decimal(col) => col.get_opt(index).map(PropRef::from),
+            PropColumn::Empty(_) => None,
         }
     }
 
-    pub(crate) fn get_mut_j(&mut self) -> &mut NodeStore {
+    pub(crate) fn len(&self) -> usize {
         match self {
-            PairEntryMut::Same { j, guard, .. } => &mut guard[*j],
-            PairEntryMut::Different { j, guard2, .. } => &mut guard2[*j],
-        }
-    }
-}
-
-pub struct EntryMut<'a, NS: 'a> {
-    i: usize,
-    guard: NS,
-    _pd: PhantomData<&'a ()>,
-}
-
-impl<'a, NS> EntryMut<'a, NS> {
-    pub fn to_mut(&mut self) -> EntryMut<'a, &mut NS> {
-        EntryMut {
-            i: self.i,
-            guard: &mut self.guard,
-            _pd: self._pd,
+            PropColumn::Bool(col) => col.len(),
+            PropColumn::I64(col) => col.len(),
+            PropColumn::U32(col) => col.len(),
+            PropColumn::U64(col) => col.len(),
+            PropColumn::F32(col) => col.len(),
+            PropColumn::F64(col) => col.len(),
+            PropColumn::Str(col) => col.len(),
+            PropColumn::U8(col) => col.len(),
+            PropColumn::U16(col) => col.len(),
+            PropColumn::I32(col) => col.len(),
+            PropColumn::List(col) => col.len(),
+            PropColumn::Map(col) => col.len(),
+            PropColumn::NDTime(col) => col.len(),
+            PropColumn::DTime(col) => col.len(),
+            PropColumn::Decimal(col) => col.len(),
+            PropColumn::Empty(count) => *count,
         }
     }
 }
 
-impl<'a, NS: DerefMut<Target = NodeSlot>> AsMut<NodeStore> for EntryMut<'a, NS> {
-    fn as_mut(&mut self) -> &mut NodeStore {
-        let slots = self.guard.deref_mut();
-        &mut slots[self.i]
-    }
-}
-
-impl<'a, NS: DerefMut<Target = NodeSlot> + 'a> EntryMut<'a, &'a mut NS> {
-    pub fn node_store_mut(&mut self) -> &mut NodeStore {
-        &mut self.guard[self.i]
-    }
-
-    pub fn t_props_log_mut(&mut self) -> &mut TColumns {
-        &mut self.guard.t_props_log
-    }
-}
-
 #[cfg(test)]
 mod test {
-    use super::{NodeStorage, TColumns};
-    use crate::entities::nodes::node_store::NodeStore;
-    use proptest::{arbitrary::any, prop_assert_eq, proptest};
-    use raphtory_api::core::entities::{properties::prop::Prop, GID, VID};
-    use rayon::prelude::*;
-    use std::borrow::Cow;
+    use super::TColumns;
+    use raphtory_api::core::entities::properties::prop::Prop;
 
     #[test]
     fn tcolumns_append_1() {
@@ -1117,91 +571,4 @@ mod test {
             ]
         );
     }
-
-    #[test]
-    fn add_5_values_to_storage() {
-        let storage = NodeStorage::new(2);
-
-        for i in 0..5 {
-            storage.push(NodeStore::empty(i.into())).init();
-        }
-
-        assert_eq!(storage.len(), 5);
-
-        for i in 0..5 {
-            let entry = storage.entry(VID(i));
-            assert_eq!(entry.as_ref().node().vid, VID(i));
-        }
-
-        let items = storage.read_lock();
-
-        let actual = items
-            .iter()
-            .map(|s| s.node().vid.index())
-            .collect::<Vec<_>>();
-
-        assert_eq!(actual, vec![0, 2, 4, 1, 3]);
-    }
-
-    #[test]
-    fn test_index_correctness() {
-        let storage = NodeStorage::new(2);
-
-        for i in 0..5 {
-            storage.push(NodeStore::empty(i.into())).init();
-        }
-        let locked = storage.read_lock();
-        let actual: Vec<_> = (0..5)
-            .map(|i| (i, locked.get(VID(i)).global_id.to_str()))
-            .collect();
-
-        assert_eq!(
-            actual,
-            vec![
-                (0usize, Cow::Borrowed("0")),
-                (1, "1".into()),
-                (2, "2".into()),
-                (3, "3".into()),
-                (4, "4".into())
-            ]
-        );
-    }
-
-    #[test]
-    fn test_entry() {
-        let storage = NodeStorage::new(2);
-
-        for i in 0..5 {
-            storage.push(NodeStore::empty(i.into())).init();
-        }
-
-        for i in 0..5 {
-            let entry = storage.entry(VID(i));
-            assert_eq!(*entry.as_ref().node().global_id.to_str(), i.to_string());
-        }
-    }
-
-    #[test]
-    fn concurrent_push() {
-        proptest!(|(v in any::<Vec<u64>>())| {
-            let storage = NodeStorage::new(16);
-            let mut expected = v
-                .into_par_iter()
-                .map(|v| {
-                    storage.push(NodeStore::empty(GID::U64(v))).init();
-                    v
-                })
-                .collect::<Vec<_>>();
-
-            let locked = storage.read_lock();
-            let mut actual: Vec<_> = locked
-                .iter()
-                .map(|n| n.node().global_id.as_u64().unwrap())
-                .collect();
-
-            actual.sort();
-            expected.sort();
-            prop_assert_eq!(actual, expected)
-        })
-    }
 }
diff --git a/raphtory-core/src/storage/node_entry.rs b/raphtory-core/src/storage/node_entry.rs
deleted file mode 100644
index ee62ac8e74..0000000000
--- a/raphtory-core/src/storage/node_entry.rs
+++ /dev/null
@@ -1,140 +0,0 @@
-use super::TColumns;
-use crate::entities::{nodes::node_store::NodeStore, properties::tprop::TPropCell};
-use itertools::Itertools;
-use raphtory_api::core::{
-    entities::{
-        edges::edge_ref::EdgeRef,
-        properties::{prop::Prop, tprop::TPropOps},
-        LayerIds,
-    },
-    storage::timeindex::EventTime,
-    Direction,
-};
-use std::{
-    fmt::{Debug, Formatter},
-    ops::Range,
-};
-
-#[derive(Copy, Clone)]
-pub struct MemRow<'a> {
-    cols: &'a TColumns,
-    row: Option<usize>,
-}
-
-impl<'a> Debug for MemRow<'a> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.debug_list().entries(*self).finish()
-    }
-}
-
-impl<'a> MemRow<'a> {
-    pub fn new(cols: &'a TColumns, row: Option<usize>) -> Self {
-        Self { cols, row }
-    }
-}
-
-impl<'a> IntoIterator for MemRow<'a> {
-    type Item = (usize, Option<Prop>);
-
-    type IntoIter = Box<dyn Iterator<Item = Self::Item> + 'a>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        Box::new(
-            self.cols
-                .iter()
-                .enumerate()
-                .map(move |(i, col)| (i, self.row.and_then(|row| col.get(row)))),
-        )
-    }
-}
-
-#[derive(Copy, Clone)]
-pub struct NodePtr<'a> {
-    pub node: &'a NodeStore,
-    t_props_log: &'a TColumns,
-}
-
-impl<'a> NodePtr<'a> {
-    pub fn edges_iter(
-        self,
-        layers: &LayerIds,
-        dir: Direction,
-    ) -> impl Iterator<Item = EdgeRef> + 'a {
-        self.node.edge_tuples(layers, dir)
-    }
-}
-
-impl<'a> Debug for NodePtr<'a> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("Node")
-            .field("gid", self.node.global_id())
-            .field("vid", &self.node.vid)
-            .field("node_type", &self.node.node_type)
-            .field("layers", &self.node.layers)
-            .field(
-                "metadata",
-                &self
-                    .node
-                    .metadata_ids()
-                    .filter_map(|i| Some((i, self.node.metadata(i)?)))
-                    .collect_vec(),
-            )
-            .field("temporal_properties", &self.into_rows().collect_vec())
-            .field("additions", self.node.timestamps())
-            .finish()
-    }
-}
-
-impl<'a> NodePtr<'a> {
-    pub fn new(node: &'a NodeStore, t_props_log: &'a TColumns) -> Self {
-        Self { node, t_props_log }
-    }
-
-    pub fn node(self) -> &'a NodeStore {
-        self.node
-    }
-
-    pub fn t_prop(self, prop_id: usize) -> TPropCell<'a> {
-        TPropCell::new(
-            &self.node.timestamps().props_ts,
-            self.t_props_log.get(prop_id),
-        )
-    }
-
-    pub fn temporal_prop_ids(self) -> impl Iterator<Item = usize> + 'a {
-        self.t_props_log
-            .t_props_log
-            .iter()
-            .enumerate()
-            .filter_map(|(id, col)| (!col.is_empty()).then_some(id))
-    }
-
-    pub fn into_rows(self) -> impl Iterator<Item = (EventTime, MemRow<'a>)> {
-        self.node
-            .timestamps()
-            .props_ts
-            .iter()
-            .map(move |(t, &row)| (*t, MemRow::new(self.t_props_log, row)))
-    }
-
-    pub fn last_before_row(self, t: EventTime) -> Vec<(usize, Prop)> {
-        self.t_props_log
-            .iter()
-            .enumerate()
-            .filter_map(|(prop_id, _)| {
-                let t_prop = self.t_prop(prop_id);
-                t_prop.last_before(t).map(|(_, v)| (prop_id, v))
-            })
-            .collect()
-    }
-
-    pub fn into_rows_window(
-        self,
-        w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, MemRow<'a>)> + Send + Sync {
-        let tcell = &self.node.timestamps().props_ts;
-        tcell
-            .iter_window(w)
-            .map(move |(t, row)| (*t, MemRow::new(self.t_props_log, *row)))
-    }
-}
diff --git a/raphtory-core/src/storage/raw_edges.rs b/raphtory-core/src/storage/raw_edges.rs
deleted file mode 100644
index b7dd07373c..0000000000
--- a/raphtory-core/src/storage/raw_edges.rs
+++ /dev/null
@@ -1,453 +0,0 @@
-use super::{resolve, timeindex::TimeIndex};
-use crate::{
-    entities::edges::edge_store::{EdgeLayer, EdgeStore, MemEdge},
-    loop_lock_write,
-};
-use itertools::Itertools;
-use lock_api::ArcRwLockReadGuard;
-use parking_lot::{RwLock, RwLockReadGuard, RwLockWriteGuard};
-use raphtory_api::core::{entities::EID, storage::timeindex::EventTime};
-use rayon::prelude::*;
-use serde::{Deserialize, Serialize};
-use std::{
-    fmt::{Debug, Formatter},
-    ops::{Deref, DerefMut},
-    sync::{
-        atomic::{self, AtomicUsize, Ordering},
-        Arc,
-    },
-};
-
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
-pub struct EdgeShard {
-    edge_ids: Vec<EdgeStore>,
-    props: Vec<Vec<EdgeLayer>>,
-    additions: Vec<Vec<TimeIndex<EventTime>>>,
-    deletions: Vec<Vec<TimeIndex<EventTime>>>,
-}
-
-#[must_use]
-pub struct UninitialisedEdge<'a> {
-    guard: RwLockWriteGuard<'a, EdgeShard>,
-    offset: usize,
-    value: EdgeStore,
-}
-
-impl<'a> UninitialisedEdge<'a> {
-    pub fn init(mut self) -> EdgeWGuard<'a> {
-        self.guard.insert(self.offset, self.value);
-        EdgeWGuard {
-            guard: self.guard,
-            i: self.offset,
-        }
-    }
-
-    pub fn value(&self) -> &EdgeStore {
-        &self.value
-    }
-
-    pub fn value_mut(&mut self) -> &mut EdgeStore {
-        &mut self.value
-    }
-}
-
-impl EdgeShard {
-    pub fn insert(&mut self, index: usize, value: EdgeStore) {
-        if index >= self.edge_ids.len() {
-            self.edge_ids.resize_with(index + 1, Default::default);
-        }
-        self.edge_ids[index] = value;
-    }
-
-    pub fn edge_store(&self, index: usize) -> &EdgeStore {
-        &self.edge_ids[index]
-    }
-
-    pub fn internal_num_layers(&self) -> usize {
-        self.additions.len().max(self.deletions.len())
-    }
-
-    pub fn additions(&self, index: usize, layer_id: usize) -> Option<&TimeIndex<EventTime>> {
-        self.additions.get(layer_id).and_then(|add| add.get(index))
-    }
-
-    pub fn deletions(&self, index: usize, layer_id: usize) -> Option<&TimeIndex<EventTime>> {
-        self.deletions.get(layer_id).and_then(|del| del.get(index))
-    }
-
-    pub fn props(&self, index: usize, layer_id: usize) -> Option<&EdgeLayer> {
-        self.props.get(layer_id).and_then(|props| props.get(index))
-    }
-
-    pub fn props_iter(&self, index: usize) -> impl Iterator<Item = (usize, &EdgeLayer)> {
-        self.props
-            .iter()
-            .enumerate()
-            .filter_map(move |(id, layer)| layer.get(index).map(|l| (id, l)))
-    }
-}
-
-#[derive(Clone, Serialize, Deserialize)]
-pub struct EdgesStorage {
-    shards: Arc<[Arc<RwLock<EdgeShard>>]>,
-    len: Arc<AtomicUsize>,
-}
-
-impl Debug for EdgesStorage {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("EdgesStorage")
-            .field("len", &self.len())
-            .field("data", &self.read_lock().iter().collect_vec())
-            .finish()
-    }
-}
-
-impl PartialEq for EdgesStorage {
-    fn eq(&self, other: &Self) -> bool {
-        self.shards.len() == other.shards.len()
-            && self
-                .shards
-                .iter()
-                .zip(other.shards.iter())
-                .all(|(a, b)| a.read_recursive().eq(&b.read_recursive()))
-    }
-}
-
-impl Default for EdgesStorage {
-    fn default() -> Self {
-        Self::new(rayon::current_num_threads())
-    }
-}
-
-impl EdgesStorage {
-    pub fn new(num_shards: usize) -> Self {
-        let shards = (0..num_shards).map(|_| {
-            Arc::new(RwLock::new(EdgeShard {
-                edge_ids: vec![],
-                props: Vec::with_capacity(0),
-                additions: Vec::with_capacity(1),
-                deletions: Vec::with_capacity(0),
-            }))
-        });
-        EdgesStorage {
-            shards: shards.collect(),
-            len: Arc::new(AtomicUsize::new(0)),
-        }
-    }
-
-    #[inline]
-    pub fn len(&self) -> usize {
-        self.len.load(atomic::Ordering::SeqCst)
-    }
-
-    pub fn next_id(&self) -> EID {
-        EID(self.len.fetch_add(1, Ordering::Relaxed))
-    }
-
-    pub fn read_lock(&self) -> LockedEdges {
-        LockedEdges {
-            shards: self
-                .shards
-                .iter()
-                .map(|shard| Arc::new(shard.read_arc_recursive()))
-                .collect(),
-            len: self.len(),
-        }
-    }
-
-    pub fn write_lock(&self) -> WriteLockedEdges<'_> {
-        WriteLockedEdges {
-            shards: self.shards.iter().map(|shard| shard.write()).collect(),
-            global_len: &self.len,
-        }
-    }
-
-    #[inline]
-    fn resolve(&self, index: usize) -> (usize, usize) {
-        resolve(index, self.shards.len())
-    }
-
-    pub(crate) fn push(&self, mut value: EdgeStore) -> UninitialisedEdge<'_> {
-        let index = self.len.fetch_add(1, atomic::Ordering::Relaxed);
-        value.eid = EID(index);
-        let (bucket, offset) = self.resolve(index);
-        let guard = loop_lock_write(&self.shards[bucket]);
-        UninitialisedEdge {
-            guard,
-            offset,
-            value,
-        }
-    }
-
-    pub fn get_edge_mut(&self, eid: EID) -> EdgeWGuard<'_> {
-        let (bucket, offset) = self.resolve(eid.into());
-        EdgeWGuard {
-            guard: loop_lock_write(&self.shards[bucket]),
-            i: offset,
-        }
-    }
-
-    pub fn get_edge(&self, eid: EID) -> EdgeRGuard<'_> {
-        let (bucket, offset) = self.resolve(eid.into());
-        EdgeRGuard {
-            guard: self.shards[bucket].read_recursive(),
-            offset,
-        }
-    }
-
-    pub fn try_get_edge(&self, eid: EID) -> Option<EdgeRGuard<'_>> {
-        let (bucket, offset) = self.resolve(eid.into());
-        let guard = self.shards.get(bucket)?.read();
-        if guard.edge_ids.get(offset)?.initialised() {
-            Some(EdgeRGuard { guard, offset })
-        } else {
-            None
-        }
-    }
-}
-
-pub struct EdgeWGuard<'a> {
-    guard: RwLockWriteGuard<'a, EdgeShard>,
-    i: usize,
-}
-
-impl<'a> EdgeWGuard<'a> {
-    pub fn as_mut(&mut self) -> MutEdge<'_> {
-        MutEdge {
-            guard: self.guard.deref_mut(),
-            i: self.i,
-        }
-    }
-
-    pub fn as_ref(&self) -> MemEdge<'_> {
-        MemEdge::new(&self.guard, self.i)
-    }
-
-    pub fn eid(&self) -> EID {
-        self.as_ref().eid()
-    }
-}
-
-pub struct MutEdge<'a> {
-    guard: &'a mut EdgeShard,
-    i: usize,
-}
-
-impl<'a> MutEdge<'a> {
-    pub fn as_ref(&self) -> MemEdge<'_> {
-        MemEdge::new(self.guard, self.i)
-    }
-    pub fn eid(&self) -> EID {
-        self.as_ref().eid()
-    }
-
-    pub fn edge_store_mut(&mut self) -> &mut EdgeStore {
-        &mut self.guard.edge_ids[self.i]
-    }
-
-    pub fn deletions_mut(&mut self, layer_id: usize) -> &mut TimeIndex<EventTime> {
-        if layer_id >= self.guard.deletions.len() {
-            self.guard
-                .deletions
-                .resize_with(layer_id + 1, Default::default);
-        }
-        if self.i >= self.guard.deletions[layer_id].len() {
-            self.guard.deletions[layer_id].resize_with(self.i + 1, Default::default);
-        }
-        &mut self.guard.deletions[layer_id][self.i]
-    }
-
-    fn has_layer(&self, layer_id: usize) -> bool {
-        if let Some(additions) = self.guard.additions.get(layer_id) {
-            if let Some(additions) = additions.get(self.i) {
-                return !additions.is_empty();
-            }
-        }
-        if let Some(deletions) = self.guard.deletions.get(layer_id) {
-            if let Some(deletions) = deletions.get(self.i) {
-                return !deletions.is_empty();
-            }
-        }
-        false
-    }
-    pub fn additions_mut(&mut self, layer_id: usize) -> &mut TimeIndex<EventTime> {
-        if layer_id >= self.guard.additions.len() {
-            self.guard
-                .additions
-                .resize_with(layer_id + 1, Default::default);
-        }
-        if self.i >= self.guard.additions[layer_id].len() {
-            self.guard.additions[layer_id].resize_with(self.i + 1, Default::default);
-        }
-        &mut self.guard.additions[layer_id][self.i]
-    }
-
-    pub fn layer_mut(&mut self, layer_id: usize) -> &mut EdgeLayer {
-        if layer_id >= self.guard.props.len() {
-            self.guard.props.resize_with(layer_id + 1, Default::default);
-        }
-        if self.i >= self.guard.props[layer_id].len() {
-            self.guard.props[layer_id].resize_with(self.i + 1, Default::default);
-        }
-
-        &mut self.guard.props[layer_id][self.i]
-    }
-
-    /// Get a mutable reference to the layer only if it already exists but don't create a new one
-    pub fn get_layer_mut(&mut self, layer_id: usize) -> Option<&mut EdgeLayer> {
-        self.has_layer(layer_id).then(|| self.layer_mut(layer_id))
-    }
-}
-
-#[derive(Debug)]
-pub struct EdgeRGuard<'a> {
-    guard: RwLockReadGuard<'a, EdgeShard>,
-    offset: usize,
-}
-
-impl<'a> EdgeRGuard<'a> {
-    pub fn as_mem_edge(&self) -> MemEdge<'_> {
-        MemEdge::new(&self.guard, self.offset)
-    }
-
-    pub fn layer_iter(
-        &self,
-    ) -> impl Iterator<Item = (usize, impl Deref<Target = EdgeLayer> + '_)> + '_ {
-        self.guard.props_iter(self.offset)
-    }
-}
-
-#[derive(Debug)]
-pub struct LockedEdges {
-    shards: Arc<[Arc<ArcRwLockReadGuard<parking_lot::RawRwLock, EdgeShard>>]>,
-    len: usize,
-}
-
-impl LockedEdges {
-    pub fn get_mem(&self, eid: EID) -> MemEdge<'_> {
-        let (bucket, offset) = resolve(eid.into(), self.shards.len());
-        MemEdge::new(&self.shards[bucket], offset)
-    }
-
-    pub fn try_get_mem(&self, eid: EID) -> Option<MemEdge<'_>> {
-        let (bucket, offset) = resolve(eid.into(), self.shards.len());
-        let guard = self.shards.get(bucket)?;
-        if guard.edge_ids.get(offset)?.initialised() {
-            Some(MemEdge::new(guard, offset))
-        } else {
-            None
-        }
-    }
-
-    pub fn len(&self) -> usize {
-        self.len
-    }
-
-    pub fn iter(&self) -> impl Iterator<Item = MemEdge<'_>> + '_ {
-        self.shards.iter().flat_map(|shard| {
-            shard
-                .edge_ids
-                .iter()
-                .enumerate()
-                .filter(|(_, e)| e.initialised())
-                .map(move |(offset, _)| MemEdge::new(shard, offset))
-        })
-    }
-
-    pub fn par_iter(&self) -> impl ParallelIterator<Item = MemEdge<'_>> + '_ {
-        self.shards.par_iter().flat_map(|shard| {
-            shard
-                .edge_ids
-                .par_iter()
-                .enumerate()
-                .filter(|(_, e)| e.initialised())
-                .map(move |(offset, _)| MemEdge::new(shard, offset))
-        })
-    }
-}
-
-pub struct EdgeShardWriter<'a, S> {
-    shard: S,
-    shard_id: usize,
-    num_shards: usize,
-    global_len: &'a AtomicUsize,
-}
-
-impl<'a, S> EdgeShardWriter<'a, S>
-where
-    S: DerefMut<Target = EdgeShard>,
-{
-    /// Map an edge id to local offset if it is in the shard
-    fn resolve(&self, eid: EID) -> Option<usize> {
-        let EID(eid) = eid;
-        let (bucket, offset) = resolve(eid, self.num_shards);
-        (bucket == self.shard_id).then_some(offset)
-    }
-
-    pub fn get_mut(&mut self, eid: EID) -> Option<MutEdge<'_>> {
-        let offset = self.resolve(eid)?;
-        if self.shard.edge_ids.len() <= offset {
-            self.global_len.fetch_max(eid.0 + 1, Ordering::Relaxed);
-            self.shard
-                .edge_ids
-                .resize_with(offset + 1, EdgeStore::default)
-        }
-        Some(MutEdge {
-            guard: self.shard.deref_mut(),
-            i: offset,
-        })
-    }
-
-    pub fn shard_id(&self) -> usize {
-        self.shard_id
-    }
-}
-
-pub struct WriteLockedEdges<'a> {
-    shards: Vec<RwLockWriteGuard<'a, EdgeShard>>,
-    global_len: &'a AtomicUsize,
-}
-
-impl<'a> WriteLockedEdges<'a> {
-    pub fn par_iter_mut(
-        &mut self,
-    ) -> impl IndexedParallelIterator<Item = EdgeShardWriter<'_, &mut EdgeShard>> + '_ {
-        let num_shards = self.shards.len();
-        let shards: Vec<_> = self
-            .shards
-            .iter_mut()
-            .map(|shard| shard.deref_mut())
-            .collect();
-        let global_len = self.global_len;
-        shards
-            .into_par_iter()
-            .enumerate()
-            .map(move |(shard_id, shard)| EdgeShardWriter {
-                shard,
-                shard_id,
-                num_shards,
-                global_len,
-            })
-    }
-
-    pub fn into_par_iter_mut(
-        self,
-    ) -> impl IndexedParallelIterator<Item = EdgeShardWriter<'a, RwLockWriteGuard<'a, EdgeShard>>> + 'a
-    {
-        let num_shards = self.shards.len();
-        let global_len = self.global_len;
-        self.shards
-            .into_par_iter()
-            .enumerate()
-            .map(move |(shard_id, shard)| EdgeShardWriter {
-                shard,
-                shard_id,
-                num_shards,
-                global_len,
-            })
-    }
-
-    pub fn num_shards(&self) -> usize {
-        self.shards.len()
-    }
-}
diff --git a/raphtory-core/src/storage/string_col.rs b/raphtory-core/src/storage/string_col.rs
new file mode 100644
index 0000000000..7db77168d3
--- /dev/null
+++ b/raphtory-core/src/storage/string_col.rs
@@ -0,0 +1,398 @@
+use crate::storage::lazy_vec::IllegalSet;
+use arrow_array::{types::StringViewType, GenericByteViewArray};
+use arrow_buffer::{bit_util::set_bit, Buffer, NullBufferBuilder};
+use arrow_data::{ByteView, MAX_INLINE_VIEW_LEN};
+use arrow_schema::ArrowError;
+
+#[derive(Copy, Clone, Debug)]
+struct BlockSizeGrowthStrategy {
+    current_size: u32,
+}
+const STARTING_BLOCK_SIZE: BlockSizeGrowthStrategy = BlockSizeGrowthStrategy {
+    current_size: 8 * 1024,
+}; // 8KiB
+const MAX_BLOCK_SIZE: u32 = 2 * 1024 * 1024; // 2MiB
+
+impl BlockSizeGrowthStrategy {
+    fn next_size(&mut self) -> u32 {
+        if self.current_size < MAX_BLOCK_SIZE {
+            // we have fixed start/end block sizes, so we can't overflow
+            self.current_size = self.current_size.saturating_mul(2);
+            self.current_size
+        } else {
+            MAX_BLOCK_SIZE
+        }
+    }
+}
+
+#[inline]
+fn inline_view(bytes: &[u8]) -> Option<u128> {
+    let len = bytes.len();
+    if len <= MAX_INLINE_VIEW_LEN as usize {
+        let mut view_buffer = [0; 16];
+        view_buffer[0..4].copy_from_slice(&(len as u32).to_le_bytes());
+        view_buffer[4..4 + len].copy_from_slice(bytes);
+        Some(u128::from_le_bytes(view_buffer))
+    } else {
+        None
+    }
+}
+
+#[derive(Debug)]
+pub struct StringColBuilder {
+    views_buffer: Vec<u128>,
+    null_buffer_builder: NullBufferBuilder,
+    completed: Vec<Buffer>,
+    in_progress: Vec<u8>,
+    block_size: BlockSizeGrowthStrategy,
+}
+
+impl StringColBuilder {
+    pub fn len(&self) -> usize {
+        self.views_buffer.len()
+    }
+
+    pub fn with_capacity(capacity: usize) -> Self {
+        Self {
+            views_buffer: Vec::with_capacity(capacity),
+            null_buffer_builder: NullBufferBuilder::new(capacity),
+            completed: vec![],
+            in_progress: vec![],
+            block_size: STARTING_BLOCK_SIZE,
+        }
+    }
+
+    pub fn get_value(&self, index: usize) -> Option<&str> {
+        let view = self.views_buffer.get(index)?;
+        if self.null_buffer_builder.is_valid(index) {
+            let len = *view as u32;
+            let bytes = if len <= MAX_INLINE_VIEW_LEN {
+                // # Safety
+                // The view is valid from the builder
+                unsafe { GenericByteViewArray::<StringViewType>::inline_value(view, len as usize) }
+            } else {
+                let view = ByteView::from(*view);
+                if view.buffer_index < self.completed.len() as u32 {
+                    let block = &self.completed[view.buffer_index as usize];
+                    &block[view.offset as usize..view.offset as usize + view.length as usize]
+                } else {
+                    &self.in_progress
+                        [view.offset as usize..view.offset as usize + view.length as usize]
+                }
+            };
+            // # Safety
+            // Strings in the builder are always valid
+            Some(unsafe { str::from_utf8_unchecked(bytes) })
+        } else {
+            None
+        }
+    }
+
+    /// Append a null value into the builder
+    #[inline]
+    pub fn append_null(&mut self) {
+        self.null_buffer_builder.append_null();
+        self.views_buffer.push(0);
+    }
+
+    #[inline]
+    fn append_value_inner(&mut self, bytes: &[u8]) -> Result<ByteView, ArrowError> {
+        let required_cap = self.in_progress.len() + bytes.len();
+        if self.in_progress.capacity() < required_cap {
+            self.flush_in_progress();
+            let to_reserve = bytes.len().max(self.block_size.next_size() as usize);
+            self.in_progress.reserve(to_reserve);
+        };
+
+        let offset = self.in_progress.len() as u32;
+        self.in_progress.extend_from_slice(bytes);
+
+        let buffer_index: u32 = self.completed.len().try_into().map_err(|_| {
+            ArrowError::InvalidArgumentError(format!(
+                "Buffer count {} exceeds u32::MAX",
+                self.completed.len()
+            ))
+        })?;
+
+        let length: u32 = bytes.len().try_into().map_err(|_| {
+            ArrowError::InvalidArgumentError(format!(
+                "String length {} exceeds u32::MAX",
+                bytes.len()
+            ))
+        })?;
+
+        let view = ByteView {
+            length,
+            // This won't panic as we checked the length of prefix earlier.
+            prefix: u32::from_le_bytes(bytes[0..4].try_into().unwrap()),
+            buffer_index,
+            offset,
+        };
+        Ok(view)
+    }
+
+    #[inline]
+    fn update_value_inner(&mut self, index: usize, bytes: &[u8]) -> Result<(), ArrowError> {
+        if let Some(inline_view) = inline_view(bytes) {
+            // inline, only need to update the view
+            self.views_buffer[index] = inline_view;
+            return Ok(());
+        }
+        let new_len: u32 = bytes.len().try_into().map_err(|_| {
+            ArrowError::InvalidArgumentError(format!(
+                "String length {} exceeds u32::MAX",
+                bytes.len()
+            ))
+        })?;
+        let old_view = self.views_buffer[index];
+        let old_len = old_view as u32;
+        if old_len >= new_len {
+            // can maybe reuse old allocation
+            let mut view = ByteView::from(old_view);
+            if view.buffer_index >= self.completed.len() as u32 {
+                self.in_progress[view.offset as usize..view.offset as usize + bytes.len()]
+                    .copy_from_slice(bytes);
+                view.length = new_len;
+                view.prefix = u32::from_le_bytes(bytes[0..4].try_into().unwrap());
+                self.views_buffer[index] = view.into();
+                return Ok(());
+            }
+        }
+        let view = self.append_value_inner(bytes)?;
+        self.views_buffer[index] = view.into();
+        Ok(())
+    }
+
+    #[inline]
+    pub fn try_append_value(&mut self, value: &str) -> Result<(), ArrowError> {
+        let v: &[u8] = value.as_ref();
+
+        if let Some(view) = inline_view(v) {
+            self.views_buffer.push(view);
+            self.null_buffer_builder.append_non_null();
+            return Ok(());
+        }
+
+        let view = self.append_value_inner(v)?;
+        self.views_buffer.push(view.into());
+        self.null_buffer_builder.append_non_null();
+
+        Ok(())
+    }
+
+    #[inline]
+    pub fn append_value(&mut self, value: &str) {
+        self.try_append_value(value).unwrap();
+    }
+
+    pub fn upsert_value(&mut self, index: usize, value: &str) -> Result<(), ArrowError> {
+        if index >= self.len() {
+            for _ in self.len()..index {
+                self.append_null();
+            }
+            self.try_append_value(value)
+        } else {
+            let bytes = value.as_bytes();
+            if let Some(inline_view) = inline_view(bytes) {
+                // inline, only need to update the view
+                self.views_buffer[index] = inline_view;
+            } else {
+                self.update_value_inner(index, bytes)?;
+            }
+            // set new entry as valid
+            if !self.null_buffer_builder.is_valid(index) {
+                let nulls = self
+                    .null_buffer_builder
+                    .as_slice_mut()
+                    .expect("NullBufferBuilder with nulls should be materialized");
+                set_bit(nulls, index);
+            }
+            Ok(())
+        }
+    }
+
+    /// Flushes the in progress block if any
+    #[inline]
+    fn flush_in_progress(&mut self) {
+        if !self.in_progress.is_empty() {
+            let f = Buffer::from_vec(std::mem::take(&mut self.in_progress));
+            self.push_completed(f)
+        }
+    }
+
+    /// Append a block to `self.completed`, checking for overflow
+    #[inline]
+    fn push_completed(&mut self, block: Buffer) {
+        assert!(block.len() < u32::MAX as usize, "Block too large");
+        assert!(self.completed.len() < u32::MAX as usize, "Too many blocks");
+        self.completed.push(block);
+    }
+}
+
+#[derive(Debug)]
+pub enum StringCol {
+    Empty {
+        len: usize,
+    },
+    One {
+        len: usize,
+        index: usize,
+        value: String,
+    },
+    Many {
+        values: StringColBuilder,
+    },
+}
+
+impl Default for StringCol {
+    fn default() -> Self {
+        StringCol::Empty { len: 0 }
+    }
+}
+impl StringCol {
+    pub fn with_len(len: usize) -> Self {
+        StringCol::Empty { len }
+    }
+
+    pub fn len(&self) -> usize {
+        match self {
+            StringCol::Empty { len } | StringCol::One { len, .. } => *len,
+            StringCol::Many { values } => values.len(),
+        }
+    }
+
+    pub fn get_opt(&self, i: usize) -> Option<&str> {
+        match self {
+            StringCol::Empty { .. } => None,
+            StringCol::One { index, value, .. } => {
+                if i == *index {
+                    Some(value)
+                } else {
+                    None
+                }
+            }
+            StringCol::Many { values } => values.get_value(i),
+        }
+    }
+
+    pub fn upsert(&mut self, new_index: usize, new_value: &str) -> Result<(), ArrowError> {
+        match self {
+            StringCol::Empty { len } => {
+                let len = (*len).max(new_index + 1);
+                *self = StringCol::One {
+                    len,
+                    index: new_index,
+                    value: new_value.to_string(),
+                };
+            }
+            StringCol::One { len, index, value } => {
+                if *index == new_index {
+                    *value = new_value.to_string();
+                } else {
+                    let len = (*len).max(new_index + 1);
+                    let (first_index, first_value, second_index, second_value) =
+                        if *index < new_index {
+                            (*index, value.as_str(), new_index, new_value)
+                        } else {
+                            (new_index, new_value, *index, value.as_str())
+                        };
+                    let mut values = StringColBuilder::with_capacity(len);
+                    for _ in 0..first_index {
+                        values.append_null();
+                    }
+                    values.append_value(first_value);
+                    for _ in first_index + 1..second_index {
+                        values.append_null();
+                    }
+                    values.append_value(second_value);
+                    for _ in second_index + 1..len {
+                        values.append_null();
+                    }
+                    *self = StringCol::Many { values };
+                }
+            }
+            StringCol::Many { values } => values.upsert_value(new_index, new_value)?,
+        }
+        Ok(())
+    }
+
+    pub fn check(&self, new_index: usize, new_value: &str) -> Result<(), IllegalSet<String>> {
+        if let Some(old_value) = self.get_opt(new_index) {
+            if old_value != new_value {
+                return Err(IllegalSet::new(
+                    new_index,
+                    old_value.to_owned(),
+                    new_value.to_owned(),
+                ));
+            }
+        }
+        Ok(())
+    }
+
+    pub fn push_value(&mut self, new_value: &str) -> Result<(), ArrowError> {
+        match self {
+            StringCol::Empty { len } => {
+                let index = *len;
+                let len = index + 1;
+                let value = new_value.to_owned();
+                *self = StringCol::One { len, index, value }
+            }
+            StringCol::One { index, value, len } => {
+                let mut values = StringColBuilder::with_capacity(*len + 1);
+                for _ in 0..*index {
+                    values.append_null();
+                }
+                values.try_append_value(value)?;
+                for _ in *index + 1..*len {
+                    values.append_null();
+                }
+                values.try_append_value(new_value)?;
+                *self = StringCol::Many { values };
+            }
+            StringCol::Many { values } => values.try_append_value(new_value)?,
+        }
+        Ok(())
+    }
+
+    pub fn push_null(&mut self) {
+        match self {
+            StringCol::Empty { len } => *len += 1,
+            StringCol::One { len, .. } => *len += 1,
+            StringCol::Many { values } => values.append_null(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::storage::string_col::StringCol;
+    use proptest::{arbitrary::any, proptest};
+    use raphtory_api::core::storage::arc_str::OptionAsStr;
+
+    #[test]
+    fn test_upsert_and_push() {
+        proptest!(|(mut old_values in proptest::collection::vec(any::<Option<String>>(), 0..100usize), new_value in any::<String>(), new_index in 0..100usize)|{
+            let mut col = StringCol::default();
+            for v in &old_values {
+                match v {
+                    None => {col.push_null()}
+                    Some(v) => {col.push_value(v).unwrap()}
+                }
+            }
+            assert_eq!(col.len(), old_values.len());
+            for (i, v) in old_values.iter().enumerate() {
+                assert_eq!(col.get_opt(i), v.as_str());
+            }
+
+            // upsert
+            col.upsert(new_index, &new_value).unwrap();
+
+            old_values.resize(old_values.len().max(new_index+1), None);
+            old_values[new_index] = Some(new_value);
+            assert_eq!(col.len(), old_values.len());
+            for (i, v) in old_values.iter().enumerate() {
+                assert_eq!(col.get_opt(i), v.as_str());
+            }
+        })
+    }
+}
diff --git a/raphtory-core/src/storage/timeindex.rs b/raphtory-core/src/storage/timeindex.rs
index d14584ac94..c92eedf414 100644
--- a/raphtory-core/src/storage/timeindex.rs
+++ b/raphtory-core/src/storage/timeindex.rs
@@ -308,7 +308,7 @@ where
     }
 
     fn range(&self, w: Range<T>) -> Self {
-        let range = match self {
+        match self {
             TimeIndexWindow::Empty => TimeIndexWindow::Empty,
             TimeIndexWindow::Range { timeindex, range } => {
                 let start = max(range.start, w.start);
@@ -326,8 +326,7 @@ where
                 timeindex: *timeindex,
                 range: w,
             },
-        };
-        range
+        }
     }
 
     fn first(&self) -> Option<T> {
@@ -376,3 +375,29 @@ where
         }
     }
 }
+
+#[cfg(test)]
+mod test {
+    use crate::{entities::properties::tcell::TCell, storage::timeindex::TimeIndexOps};
+    use raphtory_api::core::storage::timeindex::EventTime;
+
+    #[test]
+    fn window_of_window_not_empty() {
+        let mut cell: TCell<()> = TCell::default();
+        cell.set(EventTime::new(1, 0), ());
+        cell.set(EventTime::new(2, 0), ());
+        cell.set(EventTime::new(3, 0), ());
+        cell.set(EventTime::new(4, 0), ());
+        cell.set(EventTime::new(8, 0), ());
+
+        assert_eq!(cell.iter_t().count(), 5);
+
+        let cell_ref = &cell;
+        let window = EventTime::new(1, 0)..EventTime::new(8, 0);
+        let w = TimeIndexOps::range(&cell_ref, window.clone());
+        assert_eq!(w.clone().iter_t().count(), 4);
+
+        let w = TimeIndexOps::range(&w, window.clone());
+        assert_eq!(w.iter_t().count(), 4);
+    }
+}
diff --git a/raphtory-core/src/utils/iter.rs b/raphtory-core/src/utils/iter.rs
index 1c49f05c5a..73e2f7baa5 100644
--- a/raphtory-core/src/utils/iter.rs
+++ b/raphtory-core/src/utils/iter.rs
@@ -1,6 +1,7 @@
 use ouroboros::self_referencing;
 pub use raphtory_api::iter::{BoxedLDIter, BoxedLIter};
 
+/// Iterator that returns elements from a locked object.
 #[self_referencing]
 pub struct GenLockedIter<'a, O, OUT> {
     owner: O,
@@ -37,6 +38,7 @@ impl<'a, O, OUT> GenLockedIter<'a, O, OUT> {
     }
 }
 
+/// Double-ended iterator that returns elements from a locked object.
 #[self_referencing]
 pub struct GenLockedDIter<'a, O, OUT> {
     owner: O,
diff --git a/raphtory-cypher/Cargo.toml b/raphtory-cypher/Cargo.toml
index ecf235c9f6..f7917ab775 100644
--- a/raphtory-cypher/Cargo.toml
+++ b/raphtory-cypher/Cargo.toml
@@ -15,11 +15,10 @@ edition.workspace = true
 
 [dependencies]
 raphtory = { workspace = true }
-pometry-storage = { workspace = true, optional = true }
-arrow = { workspace = true }
-arrow-buffer = { workspace = true }
-arrow-schema = { workspace = true }
-arrow-array = { workspace = true }
+arrow.workspace = true
+arrow-buffer.workspace = true
+arrow-schema.workspace = true
+arrow-array.workspace = true
 
 pest.workspace = true
 pest_derive.workspace = true
@@ -42,6 +41,3 @@ pretty_assertions.workspace = true
 tempfile.workspace = true
 tokio.workspace = true
 clap.workspace = true
-
-[features]
-storage = ["raphtory/storage", "dep:pometry-storage"]
diff --git a/raphtory-graphql/Cargo.toml b/raphtory-graphql/Cargo.toml
index e2d33f41cb..081ea82f76 100644
--- a/raphtory-graphql/Cargo.toml
+++ b/raphtory-graphql/Cargo.toml
@@ -15,9 +15,9 @@ homepage.workspace = true
 [dependencies]
 raphtory = { workspace = true, features = [
     'vectors',
-    'search',
     "io",
 ] }
+tempfile = { workspace = true }
 raphtory-api = { workspace = true }
 raphtory-storage = { workspace = true }
 base64 = { workspace = true }
@@ -51,8 +51,9 @@ rustc-hash = { workspace = true }
 moka = { workspace = true }
 rayon = { workspace = true }
 ahash = { workspace = true }
-strum = {workspace = true}
-strum_macros = {workspace = true}
+strum = { workspace = true }
+strum_macros = { workspace = true }
+bigdecimal = { workspace = true, features = ["serde"] }
 
 # python binding optional dependencies
 pyo3 = { workspace = true, optional = true }
@@ -68,9 +69,9 @@ rust-embed = { workspace = true }
 parking_lot = { workspace = true }
 tempfile = { workspace = true }
 pretty_assertions = { workspace = true }
+raphtory = { workspace = true, features = ["test-utils"] }
 arrow-array = { workspace = true }
 
 [features]
-storage = ["raphtory/storage"]
 python = ["dep:pyo3", "raphtory/python"]
 search = ["raphtory/search"]
diff --git a/raphtory-graphql/schema.graphql b/raphtory-graphql/schema.graphql
index f096d609fb..c4ea2b45cc 100644
--- a/raphtory-graphql/schema.graphql
+++ b/raphtory-graphql/schema.graphql
@@ -42,7 +42,20 @@ type CollectionOfMetaGraph {
 	For example, if page(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
 	will be returned.
 	"""
-	page(limit: Int!, offset: Int, pageIndex: Int): [MetaGraph!]!
+	page(
+		"""
+		Maximum number of items to return on this page.
+		"""
+		limit: Int!,
+		"""
+		Extra items to skip on top of `pageIndex` paging (default 0).
+		"""
+		offset: Int,
+		"""
+		Zero-based page number; multiplies `limit` to determine where to start (default 0).
+		"""
+		pageIndex: Int
+	): [MetaGraph!]!
 	"""
 	Returns a count of collection objects.
 	"""
@@ -63,7 +76,20 @@ type CollectionOfNamespace {
 	For example, if page(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
 	will be returned.
 	"""
-	page(limit: Int!, offset: Int, pageIndex: Int): [Namespace!]!
+	page(
+		"""
+		Maximum number of items to return on this page.
+		"""
+		limit: Int!,
+		"""
+		Extra items to skip on top of `pageIndex` paging (default 0).
+		"""
+		offset: Int,
+		"""
+		Zero-based page number; multiplies `limit` to determine where to start (default 0).
+		"""
+		pageIndex: Int
+	): [Namespace!]!
 	"""
 	Returns a count of collection objects.
 	"""
@@ -84,7 +110,20 @@ type CollectionOfNamespacedItem {
 	For example, if page(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
 	will be returned.
 	"""
-	page(limit: Int!, offset: Int, pageIndex: Int): [NamespacedItem!]!
+	page(
+		"""
+		Maximum number of items to return on this page.
+		"""
+		limit: Int!,
+		"""
+		Extra items to skip on top of `pageIndex` paging (default 0).
+		"""
+		offset: Int,
+		"""
+		Zero-based page number; multiplies `limit` to determine where to start (default 0).
+		"""
+		pageIndex: Int
+	): [NamespacedItem!]!
 	"""
 	Returns a count of collection objects.
 	"""
@@ -128,25 +167,45 @@ type Edge {
 	
 	Errors if any of the layers do not exist.
 	"""
-	layers(names: [String!]!): Edge!
+	layers(
+		"""
+		Layer names to include.
+		"""
+		names: [String!]!
+	): Edge!
 	"""
 	Returns a view of Edge containing all layers except the excluded list of names.
 	
 	Errors if any of the layers do not exist.
 	"""
-	excludeLayers(names: [String!]!): Edge!
+	excludeLayers(
+		"""
+		Layer names to exclude.
+		"""
+		names: [String!]!
+	): Edge!
 	"""
 	Returns a view of Edge containing the specified layer.
 	
 	Errors if any of the layers do not exist.
 	"""
-	layer(name: String!): Edge!
+	layer(
+		"""
+		Layer name to include.
+		"""
+		name: String!
+	): Edge!
 	"""
 	Returns a view of Edge containing all layers except the excluded layer specified.
 	
 	Errors if any of the layers do not exist.
 	"""
-	excludeLayer(name: String!): Edge!
+	excludeLayer(
+		"""
+		Layer name to exclude.
+		"""
+		name: String!
+	): Edge!
 	"""
 	Creates a WindowSet with the given window duration and optional step using a rolling window.
 	
@@ -158,7 +217,20 @@ type Edge {
 	Note that passing a step larger than window while alignment_unit is not "Unaligned" may lead to some entries appearing before
 	the start of the first window and/or after the end of the last window (i.e. not included in any window).
 	"""
-	rolling(window: WindowDuration!, step: WindowDuration, alignmentUnit: AlignmentUnit): EdgeWindowSet!
+	rolling(
+		"""
+		Width of each window. Pass either `{epoch: <ms>}` for a discrete number of milliseconds (e.g. `{epoch: 1000}` for 1 second), or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}` or `{duration: 2 hours and 30 minutes}`).
+		"""
+		window: WindowDuration!,
+		"""
+		Optional gap between the start of one window and the start of the next. Accepts the same `{epoch: <ms>}` or `{duration: <text>}` values as `window`. Defaults to `window` — i.e. windows touch end-to-end with no overlap and no gap.
+		"""
+		step: WindowDuration,
+		"""
+		Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step` (or `window` if no step is set).
+		"""
+		alignmentUnit: AlignmentUnit
+	): EdgeWindowSet!
 	"""
 	Creates a WindowSet with the given step size using an expanding window.
 	
@@ -168,19 +240,45 @@ type Edge {
 	If unspecified (i.e. by default), alignment is done on the smallest unit of time in the step.
 	e.g. "1 month and 1 day" will align at the start of the day.
 	"""
-	expanding(step: WindowDuration!, alignmentUnit: AlignmentUnit): EdgeWindowSet!
+	expanding(
+		"""
+		How much the window grows by on each step. Pass either `{epoch: <ms>}` for a discrete number of milliseconds, or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}`).
+		"""
+		step: WindowDuration!,
+		"""
+		Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step`.
+		"""
+		alignmentUnit: AlignmentUnit
+	): EdgeWindowSet!
 	"""
 	Creates a view of the Edge including all events between the specified start (inclusive) and end (exclusive).
 	
 	For persistent graphs, any edge which exists at any point during the window will be included. You may want to restrict this to only edges that are present at the end of the window using the is_valid function.
 	"""
-	window(start: TimeInput!, end: TimeInput!): Edge!
+	window(
+		"""
+		Inclusive lower bound.
+		"""
+		start: TimeInput!,
+		"""
+		Exclusive upper bound.
+		"""
+		end: TimeInput!
+	): Edge!
 	"""
 	Creates a view of the Edge including all events at a specified time.
 	"""
-	at(time: TimeInput!): Edge!
+	at(
+		"""
+		Instant to pin the view to.
+		"""
+		time: TimeInput!
+	): Edge!
 	"""
-	Returns a view of the edge at the latest time of the graph.
+	View of this edge pinned to the graph's latest time — equivalent to
+	`at(graph.latestTime)`. The edge's properties and metadata show their
+	most recent values, and (for persistent graphs) validity is evaluated
+	at that instant.
 	"""
 	latest: Edge!
 	"""
@@ -188,7 +286,12 @@ type Edge {
 	
 	This is equivalent to before(time + 1) for Graph and at(time) for PersistentGraph.
 	"""
-	snapshotAt(time: TimeInput!): Edge!
+	snapshotAt(
+		"""
+		Instant at which entities must be valid.
+		"""
+		time: TimeInput!
+	): Edge!
 	"""
 	Creates a view of the Edge including all events that are valid at the latest time.
 	
@@ -198,36 +301,82 @@ type Edge {
 	"""
 	Creates a view of the Edge including all events before a specified end (exclusive).
 	"""
-	before(time: TimeInput!): Edge!
+	before(
+		"""
+		Exclusive upper bound.
+		"""
+		time: TimeInput!
+	): Edge!
 	"""
 	Creates a view of the Edge including all events after a specified start (exclusive).
 	"""
-	after(time: TimeInput!): Edge!
+	after(
+		"""
+		Exclusive lower bound.
+		"""
+		time: TimeInput!
+	): Edge!
 	"""
 	Shrinks both the start and end of the window.
 	"""
-	shrinkWindow(start: TimeInput!, end: TimeInput!): Edge!
+	shrinkWindow(
+		"""
+		Proposed new start (TimeInput); ignored if it would widen the window.
+		"""
+		start: TimeInput!,
+		"""
+		Proposed new end (TimeInput); ignored if it would widen the window.
+		"""
+		end: TimeInput!
+	): Edge!
 	"""
 	Set the start of the window.
 	"""
-	shrinkStart(start: TimeInput!): Edge!
+	shrinkStart(
+		"""
+		Proposed new start (TimeInput); ignored if it would widen the window.
+		"""
+		start: TimeInput!
+	): Edge!
 	"""
 	Set the end of the window.
 	"""
-	shrinkEnd(end: TimeInput!): Edge!
+	shrinkEnd(
+		"""
+		Proposed new end (TimeInput); ignored if it would widen the window.
+		"""
+		end: TimeInput!
+	): Edge!
 	"""
 	Takes a specified selection of views and applies them in given order.
 	"""
-	applyViews(views: [EdgeViewCollection!]!): Edge!
+	applyViews(
+		"""
+		Ordered list of view operations; each entry is a one-of variant (`window`, `layer`, `filter`, ...) applied to the running result.
+		"""
+		views: [EdgeViewCollection!]!
+	): Edge!
 	"""
 	Returns the earliest time of an edge.
 	"""
 	earliestTime: EventTime!
+	"""
+	The timestamp of the first event in this edge's history (first update, first
+	deletion, or anything in between). Differs from `earliestTime` in that
+	`earliestTime` reports when the edge is first *valid*; `firstUpdate` reports
+	when its history actually begins.
+	"""
 	firstUpdate: EventTime!
 	"""
 	Returns the latest time of an edge.
 	"""
 	latestTime: EventTime!
+	"""
+	The timestamp of the last event in this edge's history (last update, last
+	deletion, or anything in between). Differs from `latestTime` in that
+	`latestTime` reports when the edge is last *valid*; `lastUpdate` reports
+	when its history actually ends.
+	"""
 	lastUpdate: EventTime!
 	"""
 	Returns the time of an exploded edge. Errors on an unexploded edge.
@@ -263,12 +412,11 @@ type Edge {
 	"""
 	nbr: Node!
 	"""
-	Returns the id of the edge.
-	
-	Returns:
-	list[str]:
+	Returns the `[src, dst]` id pair of the edge. Each id is a `String`
+	for string-indexed graphs or a non-negative `Int` for integer-indexed
+	graphs.
 	"""
-	id: [String!]!
+	id: [NodeId!]!
 	"""
 	Returns a view of the properties of the edge.
 	"""
@@ -333,18 +481,27 @@ type Edge {
 	Returns: boolean
 	"""
 	isSelfLoop: Boolean!
-	filter(expr: EdgeFilter!): Edge!
+	"""
+	Apply an edge filter in place, returning an edge view whose properties /
+	metadata / history are restricted to the matching subset.
+	"""
+	filter(
+		"""
+		Composite edge filter (by property, layer, src/dst, etc.).
+		"""
+		expr: EdgeFilter!
+	): Edge!
 }
 
 input EdgeAddition {
 	"""
-	Source node.
+	Source node id (string or non-negative integer).
 	"""
-	src: String!
+	src: NodeId!
 	"""
-	Destination node.
+	Destination node id (string or non-negative integer).
 	"""
-	dst: String!
+	dst: NodeId!
 	"""
 	Layer.
 	"""
@@ -537,6 +694,11 @@ input EdgeLayersExpr {
 	expr: EdgeFilter!
 }
 
+"""
+Describes edges between a specific pair of node types — the property and
+metadata keys seen on such edges, along with their observed value types.
+One `EdgeSchema` per `(srcType, dstType)` pair per layer.
+"""
 type EdgeSchema {
 	"""
 	Returns the type of source for these edges
@@ -692,7 +854,16 @@ input EdgeWindowExpr {
 	expr: EdgeFilter!
 }
 
+"""
+A lazy sequence of per-window views of a single edge, produced by
+`edge.rolling` / `edge.expanding`. Each entry is the edge as it exists in
+that window.
+"""
 type EdgeWindowSet {
+	"""
+	Number of windows in this set. Materialising all windows is expensive for
+	large graphs — prefer `page` over `list` when iterating.
+	"""
 	count: Int!
 	"""
 	Fetch one page with a number of items up to a specified limit, optionally offset by a specified amount.
@@ -701,10 +872,32 @@ type EdgeWindowSet {
 	For example, if page(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
 	will be returned.
 	"""
-	page(limit: Int!, offset: Int, pageIndex: Int): [Edge!]!
+	page(
+		"""
+		Maximum number of items to return on this page.
+		"""
+		limit: Int!,
+		"""
+		Extra items to skip on top of `pageIndex` paging (default 0).
+		"""
+		offset: Int,
+		"""
+		Zero-based page number; multiplies `limit` to determine where to start (default 0).
+		"""
+		pageIndex: Int
+	): [Edge!]!
+	"""
+	Materialise every window as a list. Rejected by the server when bulk list
+	endpoints are disabled; use `page` for paginated access instead.
+	"""
 	list: [Edge!]!
 }
 
+"""
+A lazy collection of edges from a graph view. Supports the usual view
+transforms (window, layer, filter, ...), plus edge-specific ones like
+`explode` and `explodeLayers`, pagination, and sorting.
+"""
 type Edges {
 	"""
 	Returns a collection containing only edges in the default edge layer.
@@ -713,19 +906,39 @@ type Edges {
 	"""
 	Returns a collection containing only edges belonging to the listed layers.
 	"""
-	layers(names: [String!]!): Edges!
+	layers(
+		"""
+		Layer names to include.
+		"""
+		names: [String!]!
+	): Edges!
 	"""
 	Returns a collection containing edges belonging to all layers except the excluded list of layers.
 	"""
-	excludeLayers(names: [String!]!): Edges!
+	excludeLayers(
+		"""
+		Layer names to exclude.
+		"""
+		names: [String!]!
+	): Edges!
 	"""
 	Returns a collection containing edges belonging to the specified layer.
 	"""
-	layer(name: String!): Edges!
+	layer(
+		"""
+		Layer name to include.
+		"""
+		name: String!
+	): Edges!
 	"""
 	Returns a collection containing edges belonging to all layers except the excluded layer specified.
 	"""
-	excludeLayer(name: String!): Edges!
+	excludeLayer(
+		"""
+		Layer name to exclude.
+		"""
+		name: String!
+	): Edges!
 	"""
 	Creates a WindowSet with the given window duration and optional step using a rolling window. A rolling window is a window that moves forward by step size at each iteration.
 	
@@ -737,7 +950,20 @@ type Edges {
 	Note that passing a step larger than window while alignment_unit is not "Unaligned" may lead to some entries appearing before
 	the start of the first window and/or after the end of the last window (i.e. not included in any window).
 	"""
-	rolling(window: WindowDuration!, step: WindowDuration, alignmentUnit: AlignmentUnit): EdgesWindowSet!
+	rolling(
+		"""
+		Width of each window. Pass either `{epoch: <ms>}` for a discrete number of milliseconds (e.g. `{epoch: 1000}` for 1 second), or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}` or `{duration: 2 hours and 30 minutes}`).
+		"""
+		window: WindowDuration!,
+		"""
+		Optional gap between the start of one window and the start of the next. Accepts the same `{epoch: <ms>}` or `{duration: <text>}` values as `window`. Defaults to `window` — i.e. windows touch end-to-end with no overlap and no gap.
+		"""
+		step: WindowDuration,
+		"""
+		Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step` (or `window` if no step is set).
+		"""
+		alignmentUnit: AlignmentUnit
+	): EdgesWindowSet!
 	"""
 	Creates a WindowSet with the given step size using an expanding window. An expanding window is a window that grows by step size at each iteration.
 	
@@ -747,20 +973,51 @@ type Edges {
 	If unspecified (i.e. by default), alignment is done on the smallest unit of time in the step.
 	e.g. "1 month and 1 day" will align at the start of the day.
 	"""
-	expanding(step: WindowDuration!, alignmentUnit: AlignmentUnit): EdgesWindowSet!
+	expanding(
+		"""
+		How much the window grows by on each step. Pass either `{epoch: <ms>}` for a discrete number of milliseconds, or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}`).
+		"""
+		step: WindowDuration!,
+		"""
+		Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step`.
+		"""
+		alignmentUnit: AlignmentUnit
+	): EdgesWindowSet!
 	"""
 	Creates a view of the Edge including all events between the specified start (inclusive) and end (exclusive).
 	"""
-	window(start: TimeInput!, end: TimeInput!): Edges!
+	window(
+		"""
+		Inclusive lower bound.
+		"""
+		start: TimeInput!,
+		"""
+		Exclusive upper bound.
+		"""
+		end: TimeInput!
+	): Edges!
 	"""
 	Creates a view of the Edge including all events at a specified time.
 	"""
-	at(time: TimeInput!): Edges!
+	at(
+		"""
+		Instant to pin the view to.
+		"""
+		time: TimeInput!
+	): Edges!
+	"""
+	View showing only the latest state of each edge (equivalent to `at(latestTime)`).
+	"""
 	latest: Edges!
 	"""
 	Creates a view of the Edge including all events that are valid at time. This is equivalent to before(time + 1) for Graph and at(time) for PersistentGraph.
 	"""
-	snapshotAt(time: TimeInput!): Edges!
+	snapshotAt(
+		"""
+		Instant at which entities must be valid.
+		"""
+		time: TimeInput!
+	): Edges!
 	"""
 	Creates a view of the Edge including all events that are valid at the latest time. This is equivalent to a no-op for Graph and latest() for PersistentGraph.
 	"""
@@ -768,29 +1025,65 @@ type Edges {
 	"""
 	Creates a view of the Edge including all events before a specified end (exclusive).
 	"""
-	before(time: TimeInput!): Edges!
+	before(
+		"""
+		Exclusive upper bound.
+		"""
+		time: TimeInput!
+	): Edges!
 	"""
 	Creates a view of the Edge including all events after a specified start (exclusive).
 	"""
-	after(time: TimeInput!): Edges!
+	after(
+		"""
+		Exclusive lower bound.
+		"""
+		time: TimeInput!
+	): Edges!
 	"""
 	Shrinks both the start and end of the window.
 	"""
-	shrinkWindow(start: TimeInput!, end: TimeInput!): Edges!
+	shrinkWindow(
+		"""
+		Proposed new start (TimeInput); ignored if it would widen the window.
+		"""
+		start: TimeInput!,
+		"""
+		Proposed new end (TimeInput); ignored if it would widen the window.
+		"""
+		end: TimeInput!
+	): Edges!
 	"""
 	Set the start of the window.
 	"""
-	shrinkStart(start: TimeInput!): Edges!
+	shrinkStart(
+		"""
+		Proposed new start (TimeInput); ignored if it would widen the window.
+		"""
+		start: TimeInput!
+	): Edges!
 	"""
 	Set the end of the window.
 	"""
-	shrinkEnd(end: TimeInput!): Edges!
+	shrinkEnd(
+		"""
+		Proposed new end (TimeInput); ignored if it would widen the window.
+		"""
+		end: TimeInput!
+	): Edges!
 	"""
 	Takes a specified selection of views and applies them in order given.
 	"""
-	applyViews(views: [EdgesViewCollection!]!): Edges!
+	applyViews(
+		"""
+		Ordered list of view operations; each entry is a one-of variant (`window`, `layer`, `filter`, ...) applied to the running result.
+		"""
+		views: [EdgesViewCollection!]!
+	): Edges!
 	"""
-	Returns an edge object for each update within the original edge.
+	Expand each edge into one edge per update: if `A->B` has three updates, it
+	becomes three `A->B` entries each at a distinct timestamp. Use this to
+	iterate per-event rather than per-edge.
 	"""
 	explode: Edges!
 	"""
@@ -800,9 +1093,15 @@ type Edges {
 	"""
 	explodeLayers: Edges!
 	"""
-	Specify a sort order from: source, destination, property, time. You can also reverse the ordering.
+	Sort the edges. Multiple criteria are applied lexicographically (ties
+	on the first key break to the second, etc.).
 	"""
-	sorted(sortBys: [EdgeSortBy!]!): Edges!
+	sorted(
+		"""
+		Ordered list of sort keys. Each entry chooses exactly one of `src` / `dst` / `time` / `property`, with an optional `reverse: true` to flip order.
+		"""
+		sortBys: [EdgeSortBy!]!
+	): Edges!
 	"""
 	Returns the start time of the window or none if there is no window.
 	"""
@@ -825,19 +1124,73 @@ type Edges {
 	For example, if page(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
 	will be returned.
 	"""
-	page(limit: Int!, offset: Int, pageIndex: Int): [Edge!]!
+	page(
+		"""
+		Maximum number of items to return on this page.
+		"""
+		limit: Int!,
+		"""
+		Extra items to skip on top of `pageIndex` paging (default 0).
+		"""
+		offset: Int,
+		"""
+		Zero-based page number; multiplies `limit` to determine where to start (default 0).
+		"""
+		pageIndex: Int
+	): [Edge!]!
 	"""
 	Returns a list of all objects in the current selection of the collection. You should filter the collection first then call list.
 	"""
 	list: [Edge!]!
 	"""
-	Returns a filtered view that applies to list down the chain
-	"""
-	filter(expr: EdgeFilter!): Edges!
+	Narrow the collection to edges matching `expr`. The filter sticks to the
+	returned view — every subsequent traversal through these edges (their
+	properties, their endpoints' neighbours, etc.) continues to see the
+	filtered scope.
+	
+	Useful when you want one scoping rule to apply across the whole query.
+	E.g. restricting everything to a specific week:
+	
+	```text
+	edges { filter(expr: {window: {start: 1234, end: 5678}}) {
+	list { src { neighbours { list { name } } } }   # neighbours still windowed
+	} }
+	```
+	
+	Contrast with `select`, which applies here and is not carried through.
 	"""
-	Returns filtered list of edges
+	filter(
+		"""
+		Composite edge filter (by property, layer, src/dst, etc.).
+		"""
+		expr: EdgeFilter!
+	): Edges!
 	"""
-	select(expr: EdgeFilter!): Edges!
+	Narrow the collection to edges matching `expr`, but only at this step —
+	subsequent traversals out of these edges see the unfiltered graph again.
+	
+	Useful when you want different scopes at different hops. E.g. Monday's
+	edges, then the neighbours of their endpoints on Tuesday, then *those*
+	neighbours on Wednesday:
+	
+	```text
+	edges { select(expr: {window: {...monday...}}) {
+	list { src { select(expr: {window: {...tuesday...}}) {
+	neighbours { select(expr: {window: {...wednesday...}}) {
+	neighbours { list { name } }
+	} }
+	} } }
+	} }
+	```
+	
+	Contrast with `filter`, which persists the scope through subsequent ops.
+	"""
+	select(
+		"""
+		Composite edge filter (by property, layer, src/dst, etc.).
+		"""
+		expr: EdgeFilter!
+	): Edges!
 }
 
 input EdgesViewCollection @oneOf {
@@ -903,7 +1256,16 @@ input EdgesViewCollection @oneOf {
 	edgeFilter: EdgeFilter
 }
 
+"""
+A lazy sequence of per-window edge collections, produced by
+`edges.rolling` / `edges.expanding`. Each entry is an `Edges` collection
+as it exists in that window.
+"""
 type EdgesWindowSet {
+	"""
+	Number of windows in this set. Materialising all windows is expensive for
+	large graphs — prefer `page` over `list` when iterating.
+	"""
 	count: Int!
 	"""
 	Fetch one page with a number of items up to a specified limit, optionally offset by a specified amount.
@@ -912,7 +1274,24 @@ type EdgesWindowSet {
 	For example, if page(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
 	will be returned.
 	"""
-	page(limit: Int!, offset: Int, pageIndex: Int): [Edges!]!
+	page(
+		"""
+		Maximum number of items to return on this page.
+		"""
+		limit: Int!,
+		"""
+		Extra items to skip on top of `pageIndex` paging (default 0).
+		"""
+		offset: Int,
+		"""
+		Zero-based page number; multiplies `limit` to determine where to start (default 0).
+		"""
+		pageIndex: Int
+	): [Edges!]!
+	"""
+	Materialise every window as a list. Rejected by the server when bulk list
+	endpoints are disabled; use `page` for paginated access instead.
+	"""
 	list: [Edges!]!
 }
 
@@ -951,50 +1330,113 @@ type EventTime {
 	Refer to chrono::format::strftime for formatting specifiers and escape sequences.
 	Raises an error if a time conversion fails.
 	"""
-	datetime(formatString: String): String
+	datetime(
+		"""
+		Optional format string for the rendered datetime. Uses `%`-style specifiers — for example `%Y-%m-%d` for `2024-01-15`, `%Y-%m-%d %H:%M:%S` for `2024-01-15 10:30:00`, or `%H:%M` for `10:30`. Defaults to RFC 3339 (e.g. `2024-01-15T10:30:45.123+00:00`) when omitted.
+		"""
+		formatString: String
+	): String
 }
 
+"""
+A view of a Raphtory graph. Every field here returns either data from the
+view or a derived view (`window`, `layer`, `at`, `filter`, ...) that you can
+keep chaining. Views are cheap — they don't copy the underlying data.
+"""
 type Graph {
 	"""
 	Returns the names of all layers in the graphview.
+	Distinct layer names observed in the current view — any layer that has at
+	least one edge event visible here. Excludes layers that exist elsewhere in
+	the graph but whose edges have been filtered out.
 	"""
 	uniqueLayers: [String!]!
 	"""
-	Returns a view containing only the default layer.
+	View restricted to the default layer — where nodes and edges end up
+	when `addNode` / `addEdge` is called without a `layer` argument.
+	Useful for separating "unlayered" base-graph events from named-layer
+	ones.
 	"""
 	defaultLayer: Graph!
 	"""
-	Returns a view containing all the specified layers.
-	"""
-	layers(names: [String!]!): Graph!
-	"""
-	Returns a view containing all layers except the specified excluded layers.
-	"""
-	excludeLayers(names: [String!]!): Graph!
-	"""
-	Returns a view containing the layer specified.
-	"""
-	layer(name: String!): Graph!
-	"""
-	Returns a view containing all layers except the specified excluded layer.
-	"""
-	excludeLayer(name: String!): Graph!
-	"""
-	Returns a subgraph of a specified set of nodes which contains only the edges that connect nodes of the subgraph to each other.
-	"""
-	subgraph(nodes: [String!]!): Graph!
-	"""
-	Returns a view of the graph that only includes valid edges.
+	View restricted to the named layers. Updates on any other layer are hidden;
+	if that leaves a node or edge with no updates left, it disappears from the
+	view.
+	"""
+	layers(
+		"""
+		Layer names to include.
+		"""
+		names: [String!]!
+	): Graph!
+	"""
+	View with the named layers hidden. Updates on those layers are removed; if
+	that leaves a node or edge with no updates left, it disappears from the
+	view.
+	"""
+	excludeLayers(
+		"""
+		Layer names to exclude.
+		"""
+		names: [String!]!
+	): Graph!
+	"""
+	View restricted to a single layer. Convenience form of
+	`layers(names: [name])` — updates on any other layer are hidden, and
+	entities with nothing left disappear.
+	"""
+	layer(
+		"""
+		Layer name to include.
+		"""
+		name: String!
+	): Graph!
+	"""
+	View with one layer hidden. Convenience form of
+	`excludeLayers(names: [name])` — updates on that layer are removed, and
+	entities with nothing left disappear.
+	"""
+	excludeLayer(
+		"""
+		Layer name to exclude.
+		"""
+		name: String!
+	): Graph!
+	"""
+	View restricted to a chosen set of nodes and the edges between them. Edges
+	connecting a selected node to a non-selected node are hidden.
+	"""
+	subgraph(
+		"""
+		Node ids to keep.
+		"""
+		nodes: [NodeId!]!
+	): Graph!
+	"""
+	View containing only valid edges — for persistent graphs this drops edges
+	whose most recent event is a deletion at the latest time of the current
+	view (a later re-addition would keep them). On event graphs this is a
+	no-op.
 	"""
 	valid: Graph!
 	"""
-	Returns a subgraph filtered by the specified node types.
+	View restricted to nodes with the given node types.
 	"""
-	subgraphNodeTypes(nodeTypes: [String!]!): Graph!
+	subgraphNodeTypes(
+		"""
+		Node types to include.
+		"""
+		nodeTypes: [String!]!
+	): Graph!
 	"""
-	Returns a subgraph containing all nodes except the specified excluded nodes.
+	View with a set of nodes removed (along with any edges touching them).
 	"""
-	excludeNodes(nodes: [String!]!): Graph!
+	excludeNodes(
+		"""
+		Node ids to exclude.
+		"""
+		nodes: [NodeId!]!
+	): Graph!
 	"""
 	Creates a rolling window with the specified window size and an optional step.
 	
@@ -1006,7 +1448,20 @@ type Graph {
 	Note that passing a step larger than window while alignment_unit is not "Unaligned" may lead to some entries appearing before
 	the start of the first window and/or after the end of the last window (i.e. not included in any window).
 	"""
-	rolling(window: WindowDuration!, step: WindowDuration, alignmentUnit: AlignmentUnit): GraphWindowSet!
+	rolling(
+		"""
+		Width of each window. Pass either `{epoch: <ms>}` for a discrete number of milliseconds (e.g. `{epoch: 1000}` for 1 second), or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}` or `{duration: 2 hours and 30 minutes}`).
+		"""
+		window: WindowDuration!,
+		"""
+		Optional gap between the start of one window and the start of the next. Accepts the same `{epoch: <ms>}` or `{duration: <text>}` values as `window`. Defaults to `window` — i.e. windows touch end-to-end with no overlap and no gap.
+		"""
+		step: WindowDuration,
+		"""
+		Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step` (or `window` if no step is set).
+		"""
+		alignmentUnit: AlignmentUnit
+	): GraphWindowSet!
 	"""
 	Creates an expanding window with the specified step size.
 	
@@ -1016,15 +1471,38 @@ type Graph {
 	If unspecified (i.e. by default), alignment is done on the smallest unit of time in the step.
 	e.g. "1 month and 1 day" will align at the start of the day.
 	"""
-	expanding(step: WindowDuration!, alignmentUnit: AlignmentUnit): GraphWindowSet!
+	expanding(
+		"""
+		How much the window grows by on each step. Pass either `{epoch: <ms>}` for a discrete number of milliseconds, or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}`).
+		"""
+		step: WindowDuration!,
+		"""
+		Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step`.
+		"""
+		alignmentUnit: AlignmentUnit
+	): GraphWindowSet!
 	"""
 	Return a graph containing only the activity between start and end, by default raphtory stores times in milliseconds from the unix epoch.
 	"""
-	window(start: TimeInput!, end: TimeInput!): Graph!
+	window(
+		"""
+		Inclusive lower bound.
+		"""
+		start: TimeInput!,
+		"""
+		Exclusive upper bound.
+		"""
+		end: TimeInput!
+	): Graph!
 	"""
 	Creates a view including all events at a specified time.
 	"""
-	at(time: TimeInput!): Graph!
+	at(
+		"""
+		Instant to pin the view to.
+		"""
+		time: TimeInput!
+	): Graph!
 	"""
 	Creates a view including all events at the latest time.
 	"""
@@ -1032,7 +1510,12 @@ type Graph {
 	"""
 	Create a view including all events that are valid at the specified time.
 	"""
-	snapshotAt(time: TimeInput!): Graph!
+	snapshotAt(
+		"""
+		Instant at which entities must be valid.
+		"""
+		time: TimeInput!
+	): Graph!
 	"""
 	Create a view including all events that are valid at the latest time.
 	"""
@@ -1040,25 +1523,57 @@ type Graph {
 	"""
 	Create a view including all events before a specified end (exclusive).
 	"""
-	before(time: TimeInput!): Graph!
+	before(
+		"""
+		Exclusive upper bound.
+		"""
+		time: TimeInput!
+	): Graph!
 	"""
 	Create a view including all events after a specified start (exclusive).
 	"""
-	after(time: TimeInput!): Graph!
-	"""
-	Shrink both the start and end of the window.
-	"""
-	shrinkWindow(start: TimeInput!, end: TimeInput!): Graph!
+	after(
+		"""
+		Exclusive lower bound.
+		"""
+		time: TimeInput!
+	): Graph!
+	"""
+	Shrink both the start and end of the window. The new bounds are taken as the
+	intersection with the current window; this never widens the view.
+	"""
+	shrinkWindow(
+		"""
+		Proposed new start (TimeInput); ignored if before the current start.
+		"""
+		start: TimeInput!,
+		"""
+		Proposed new end (TimeInput); ignored if after the current end.
+		"""
+		end: TimeInput!
+	): Graph!
 	"""
 	Set the start of the window to the larger of the specified value or current start.
 	"""
-	shrinkStart(start: TimeInput!): Graph!
+	shrinkStart(
+		"""
+		Proposed new start (TimeInput); has no effect if it would widen the window.
+		"""
+		start: TimeInput!
+	): Graph!
 	"""
 	Set the end of the window to the smaller of the specified value or current end.
 	"""
-	shrinkEnd(end: TimeInput!): Graph!
+	shrinkEnd(
+		"""
+		Proposed new end (TimeInput); has no effect if it would widen the window.
+		"""
+		end: TimeInput!
+	): Graph!
 	"""
-	Returns the timestamp for the creation of the graph.
+	Filesystem creation timestamp (epoch millis) of the graph's on-disk folder
+	— i.e. when this graph was first saved to the server, not when its earliest
+	event occurred. Use `earliestTime` for the latter.
 	"""
 	created: Int!
 	"""
@@ -1086,13 +1601,26 @@ type Graph {
 	"""
 	end: EventTime!
 	"""
-	Returns the earliest time that any edge in this graph is valid.
+	The earliest time at which any edge in this graph is valid.
+	
+	* `includeNegative` — if false, edge events with a timestamp `< 0` are
+	skipped when computing the minimum. Defaults to true.
 	"""
-	earliestEdgeTime(includeNegative: Boolean): EventTime!
+	earliestEdgeTime(
+		"""
+		If false, edge events with a timestamp `< 0` are skipped when computing the minimum. Defaults to true.
+		"""
+		includeNegative: Boolean
+	): EventTime!
 	"""
-	Returns the latest time that any edge in this graph is valid.
+	The latest time at which any edge in this graph is valid.
 	"""
-	latestEdgeTime(includeNegative: Boolean): EventTime!
+	latestEdgeTime(
+		"""
+		If false, edge events with a timestamp `< 0` are skipped when computing the maximum. Defaults to true.
+		"""
+		includeNegative: Boolean
+	): EventTime!
 	"""
 	Returns the number of edges in the graph.
 	
@@ -1111,29 +1639,74 @@ type Graph {
 	"""
 	countNodes: Int!
 	"""
-	Returns true if the graph contains the specified node.
-	"""
-	hasNode(name: String!): Boolean!
-	"""
-	Returns true if the graph contains the specified edge. Edges are specified by providing a source and destination node id. You can restrict the search to a specified layer.
-	"""
-	hasEdge(src: String!, dst: String!, layer: String): Boolean!
-	"""
-	Gets the node with the specified id.
-	"""
-	node(name: String!): Node
-	"""
-	Gets (optionally a subset of) the nodes in the graph.
-	"""
-	nodes(select: NodeFilter): Nodes!
-	"""
-	Gets the edge with the specified source and destination nodes.
-	"""
-	edge(src: String!, dst: String!): Edge
-	"""
-	Gets the edges in the graph.
-	"""
-	edges(select: EdgeFilter): Edges!
+	Returns true if a node with the given id exists in this view.
+	"""
+	hasNode(
+		"""
+		Node id to look up.
+		"""
+		name: NodeId!
+	): Boolean!
+	"""
+	Returns true if an edge exists between `src` and `dst` in this view, optionally
+	restricted to a single layer.
+	"""
+	hasEdge(
+		"""
+		Source node id.
+		"""
+		src: NodeId!,
+		"""
+		Destination node id.
+		"""
+		dst: NodeId!,
+		"""
+		Optional; if provided, only checks whether the edge exists on this layer. If null or omitted, any layer counts.
+		"""
+		layer: String
+	): Boolean!
+	"""
+	Look up a single node by id. Returns null if the node doesn't exist in this
+	view.
+	"""
+	node(
+		"""
+		Node id.
+		"""
+		name: NodeId!
+	): Node
+	"""
+	All nodes in this view, optionally narrowed by a filter.
+	"""
+	nodes(
+		"""
+		Optional node filter (by name, property, type, etc.). If omitted, every node in the view is returned.
+		"""
+		select: NodeFilter
+	): Nodes!
+	"""
+	Look up a single edge by its endpoint ids. Returns null if no edge exists
+	between `src` and `dst` in this view.
+	"""
+	edge(
+		"""
+		Source node id.
+		"""
+		src: NodeId!,
+		"""
+		Destination node id.
+		"""
+		dst: NodeId!
+	): Edge
+	"""
+	All edges in this view, optionally narrowed by a filter.
+	"""
+	edges(
+		"""
+		Optional edge filter (by property, layer, src/dst, etc.). If omitted, every edge in the view is returned.
+		"""
+		select: EdgeFilter
+	): Edges!
 	"""
 	Returns the properties of the graph.
 	"""
@@ -1158,36 +1731,116 @@ type Graph {
 	Returns the graph schema.
 	"""
 	schema: GraphSchema!
-	algorithms: GraphAlgorithmPlugin!
-	sharedNeighbours(selectedNodes: [String!]!): [Node!]!
 	"""
-	Export all nodes and edges from this graph view to another existing graph
+	Access registered graph algorithms (PageRank, shortest path, etc.) for this
+	graph view. The set of available algorithms is defined by the plugin registry
+	loaded at server startup.
 	"""
-	exportTo(path: String!): Boolean!
-	filter(expr: GraphFilter): Graph!
-	filterNodes(expr: NodeFilter!): Graph!
-	filterEdges(expr: EdgeFilter!): Graph!
+	algorithms: GraphAlgorithmPlugin!
+	"""
+	Nodes that are neighbours of every node in `selectedNodes`. Returns the
+	intersection of each selected node's neighbour set (undirected).
+	"""
+	sharedNeighbours(
+		"""
+		Node ids whose common neighbours you want. Returns an empty list if `selectedNodes` is empty or any id does not exist.
+		"""
+		selectedNodes: [NodeId!]!
+	): [Node!]!
+	"""
+	Copy all nodes and edges of the current graph view into another already-
+	existing graph stored on the server. The destination graph is preserved
+	— this only adds; it does not replace.
+	"""
+	exportTo(
+		"""
+		Destination graph path relative to the root namespace.
+		"""
+		path: String!
+	): Boolean!
+	"""
+	Returns a filtered view of the graph. Applies a mixed node/edge filter
+	expression and narrows nodes, edges, and their properties to what matches.
+	"""
+	filter(
+		"""
+		Optional composite filter combining node, edge, property, and metadata conditions. If omitted, applies the identity filter (equivalent to no filtering).
+		"""
+		expr: GraphFilter
+	): Graph!
+	"""
+	Returns a graph view restricted to nodes that match the given filter; edges
+	are kept only if both endpoints survive.
+	"""
+	filterNodes(
+		"""
+		Composite node filter (by name, property, type, etc.).
+		"""
+		expr: NodeFilter!
+	): Graph!
+	"""
+	Returns a graph view restricted to edges that match the given filter. Nodes
+	remain in the view even if all their edges are filtered out.
+	"""
+	filterEdges(
+		"""
+		Composite edge filter (by property, layer, src/dst, etc.).
+		"""
+		expr: EdgeFilter!
+	): Graph!
 	"""
 	(Experimental) Get index specification.
 	"""
 	getIndexSpec: IndexSpec!
 	"""
-	(Experimental) Searches for nodes which match the given filter expression.
-	
-	Uses Tantivy's exact search.
-	"""
-	searchNodes(filter: NodeFilter!, limit: Int!, offset: Int!): [Node!]!
-	"""
-	(Experimental) Searches the index for edges which match the given filter expression.
-	
-	Uses Tantivy's exact search.
-	"""
-	searchEdges(filter: EdgeFilter!, limit: Int!, offset: Int!): [Edge!]!
-	"""
-	Returns the specified graph view or if none is specified returns the default view.
-	This allows you to specify multiple operations together.
-	"""
-	applyViews(views: [GraphViewCollection!]!): Graph!
+	(Experimental) Searches for nodes which match the given filter
+	expression. Uses Tantivy's exact search; requires the graph to have
+	been indexed.
+	"""
+	searchNodes(
+		"""
+		Composite node filter (by name, property, type, etc.).
+		"""
+		filter: NodeFilter!,
+		"""
+		Maximum number of nodes to return.
+		"""
+		limit: Int!,
+		"""
+		Number of matches to skip before returning results.
+		"""
+		offset: Int!
+	): [Node!]!
+	"""
+	(Experimental) Searches the index for edges which match the given
+	filter expression. Uses Tantivy's exact search; requires the graph to
+	have been indexed.
+	"""
+	searchEdges(
+		"""
+		Composite edge filter (by property, layer, src/dst, etc.).
+		"""
+		filter: EdgeFilter!,
+		"""
+		Maximum number of edges to return.
+		"""
+		limit: Int!,
+		"""
+		Number of matches to skip before returning results.
+		"""
+		offset: Int!
+	): [Edge!]!
+	"""
+	Apply a list of view operations in the given order and return the
+	resulting graph view. Lets callers compose multiple view transforms
+	(window, layer, filter, snapshot, ...) in a single call.
+	"""
+	applyViews(
+		"""
+		Ordered list of view operations; each entry is a one-of variant applied to the running result.
+		"""
+		views: [GraphViewCollection!]!
+	): Graph!
 }
 
 type GraphAlgorithmPlugin {
@@ -1327,7 +1980,7 @@ input GraphViewCollection @oneOf {
 	"""
 	Subgraph nodes.
 	"""
-	subgraph: [String!]
+	subgraph: [NodeId!]
 	"""
 	Subgraph node types.
 	"""
@@ -1335,7 +1988,7 @@ input GraphViewCollection @oneOf {
 	"""
 	List of excluded nodes.
 	"""
-	excludeNodes: [String!]
+	excludeNodes: [NodeId!]
 	"""
 	Valid state.
 	"""
@@ -1418,9 +2071,16 @@ input GraphWindowExpr {
 	expr: GraphFilter
 }
 
+"""
+A lazy sequence of graph snapshots produced by `rolling` or `expanding`.
+Each entry is a `Graph` at a different window over time. Iterate via
+`list` / `page` (or count with `count`). Subsequent view ops apply
+per-window.
+"""
 type GraphWindowSet {
 	"""
-	Returns the number of items.
+	Number of windows in this set. Materialising all windows is expensive for
+	large graphs — prefer `page` over `list` when iterating.
 	"""
 	count: Int!
 	"""
@@ -1430,7 +2090,24 @@ type GraphWindowSet {
 	For example, if page(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
 	will be returned.
 	"""
-	page(limit: Int!, offset: Int, pageIndex: Int): [Graph!]!
+	page(
+		"""
+		Maximum number of items to return on this page.
+		"""
+		limit: Int!,
+		"""
+		Extra items to skip on top of `pageIndex` paging (default 0).
+		"""
+		offset: Int,
+		"""
+		Zero-based page number; multiplies `limit` to determine where to start (default 0).
+		"""
+		pageIndex: Int
+	): [Graph!]!
+	"""
+	Materialise every window as a list. Rejected by the server when bulk list
+	endpoints are disabled; use `page` for paginated access instead.
+	"""
 	list: [Graph!]!
 }
 
@@ -1462,7 +2139,20 @@ type History {
 	For example, if page(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
 	will be returned.
 	"""
-	page(limit: Int!, offset: Int, pageIndex: Int): [EventTime!]!
+	page(
+		"""
+		Maximum number of items to return on this page.
+		"""
+		limit: Int!,
+		"""
+		Extra items to skip on top of `pageIndex` paging (default 0).
+		"""
+		offset: Int,
+		"""
+		Zero-based page number; multiplies `limit` to determine where to start (default 0).
+		"""
+		pageIndex: Int
+	): [EventTime!]!
 	"""
 	Fetch one page of EventTime entries with a number of items up to a specified limit,
 	optionally offset by a specified amount. The page_index sets the number of pages to skip (defaults to 0).
@@ -1470,7 +2160,20 @@ type History {
 	For example, if page_rev(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
 	will be returned.
 	"""
-	pageRev(limit: Int!, offset: Int, pageIndex: Int): [EventTime!]!
+	pageRev(
+		"""
+		Maximum number of items to return on this page.
+		"""
+		limit: Int!,
+		"""
+		Extra items to skip on top of `pageIndex` paging (default 0).
+		"""
+		offset: Int,
+		"""
+		Zero-based page number; multiplies `limit` to determine where to start (default 0).
+		"""
+		pageIndex: Int
+	): [EventTime!]!
 	"""
 	Returns True if the history is empty.
 	"""
@@ -1490,14 +2193,22 @@ type History {
 	Optionally, a format string can be passed to format the output. Defaults to RFC 3339 if not provided (e.g., "2023-12-25T10:30:45.123Z").
 	Refer to chrono::format::strftime for formatting specifiers and escape sequences.
 	"""
-	datetimes(formatString: String): HistoryDateTime!
+	datetimes(
+		"""
+		Optional format string for the rendered datetime. Uses `%`-style specifiers — for example `%Y-%m-%d` for `2024-01-15`, `%Y-%m-%d %H:%M:%S` for `2024-01-15 10:30:00`, or `%H:%M` for `10:30`. Defaults to RFC 3339 (e.g. `2024-01-15T10:30:45.123+00:00`) when omitted.
+		"""
+		formatString: String
+	): HistoryDateTime!
 	"""
 	Returns a HistoryEventId object which accesses event ids of EventTime entries.
 	They are used for ordering within the same timestamp.
 	"""
 	eventId: HistoryEventId!
 	"""
-	Returns an Intervals object which calculates the intervals between consecutive EventTime timestamps.
+	Inter-event gap analysis for this history. The returned `Intervals`
+	object exposes each gap (in milliseconds) between consecutive events,
+	plus summary statistics — `min` / `max` / `mean` / `median` — and
+	paginated access via `list` / `listRev` / `page` / `pageRev`.
 	"""
 	intervals: Intervals!
 }
@@ -1511,13 +2222,23 @@ type HistoryDateTime {
 	If filter_broken is set to True, time conversion errors will be ignored. If set to False, a TimeError
 	will be raised on time conversion error. Defaults to False.
 	"""
-	list(filterBroken: Boolean): [String!]!
+	list(
+		"""
+		If true, ignore unconvertible timestamps; if false, raise an error on the first conversion failure. Defaults to false.
+		"""
+		filterBroken: Boolean
+	): [String!]!
 	"""
 	List all datetimes formatted as strings in reverse chronological order.
 	If filter_broken is set to True, time conversion errors will be ignored. If set to False, a TimeError
 	will be raised on time conversion error. Defaults to False.
 	"""
-	listRev(filterBroken: Boolean): [String!]!
+	listRev(
+		"""
+		If true, ignore unconvertible timestamps; if false, raise an error on the first conversion failure. Defaults to false.
+		"""
+		filterBroken: Boolean
+	): [String!]!
 	"""
 	Fetch one page of datetimes formatted as string with a number of items up to a specified limit,
 	optionally offset by a specified amount. The page_index sets the number of pages to skip (defaults to 0).
@@ -1527,7 +2248,24 @@ type HistoryDateTime {
 	For example, if page(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
 	will be returned.
 	"""
-	page(limit: Int!, offset: Int, pageIndex: Int, filterBroken: Boolean): [String!]!
+	page(
+		"""
+		Maximum number of items to return on this page.
+		"""
+		limit: Int!,
+		"""
+		Extra items to skip on top of `pageIndex` paging (default 0).
+		"""
+		offset: Int,
+		"""
+		Zero-based page number; multiplies `limit` to determine where to start (default 0).
+		"""
+		pageIndex: Int,
+		"""
+		If true, skip timestamps whose conversion fails; if false, raise an error on the first conversion failure. Defaults to false.
+		"""
+		filterBroken: Boolean
+	): [String!]!
 	"""
 	Fetch one page of datetimes formatted as string in reverse chronological order with a number of items up to a specified limit,
 	optionally offset by a specified amount. The page_index sets the number of pages to skip (defaults to 0).
@@ -1537,7 +2275,24 @@ type HistoryDateTime {
 	For example, if page_rev(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
 	will be returned.
 	"""
-	pageRev(limit: Int!, offset: Int, pageIndex: Int, filterBroken: Boolean): [String!]!
+	pageRev(
+		"""
+		Maximum number of items to return on this page.
+		"""
+		limit: Int!,
+		"""
+		Extra items to skip on top of `pageIndex` paging (default 0).
+		"""
+		offset: Int,
+		"""
+		Zero-based page number; multiplies `limit` to determine where to start (default 0).
+		"""
+		pageIndex: Int,
+		"""
+		If true, skip timestamps whose conversion fails; if false, raise an error on the first conversion failure. Defaults to false.
+		"""
+		filterBroken: Boolean
+	): [String!]!
 }
 
 """
@@ -1559,7 +2314,20 @@ type HistoryEventId {
 	For example, if page(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
 	will be returned.
 	"""
-	page(limit: Int!, offset: Int, pageIndex: Int): [Int!]!
+	page(
+		"""
+		Maximum number of items to return on this page.
+		"""
+		limit: Int!,
+		"""
+		Extra items to skip on top of `pageIndex` paging (default 0).
+		"""
+		offset: Int,
+		"""
+		Zero-based page number; multiplies `limit` to determine where to start (default 0).
+		"""
+		pageIndex: Int
+	): [Int!]!
 	"""
 	Fetch one page of event ids in reverse chronological order with a number of items up to a specified limit,
 	optionally offset by a specified amount. The page_index sets the number of pages to skip (defaults to 0).
@@ -1567,7 +2335,20 @@ type HistoryEventId {
 	For example, if page_rev(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
 	will be returned.
 	"""
-	pageRev(limit: Int!, offset: Int, pageIndex: Int): [Int!]!
+	pageRev(
+		"""
+		Maximum number of items to return on this page.
+		"""
+		limit: Int!,
+		"""
+		Extra items to skip on top of `pageIndex` paging (default 0).
+		"""
+		offset: Int,
+		"""
+		Zero-based page number; multiplies `limit` to determine where to start (default 0).
+		"""
+		pageIndex: Int
+	): [Int!]!
 }
 
 """
@@ -1589,7 +2370,20 @@ type HistoryTimestamp {
 	For example, if page(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
 	will be returned.
 	"""
-	page(limit: Int!, offset: Int, pageIndex: Int): [Int!]!
+	page(
+		"""
+		Maximum number of items to return on this page.
+		"""
+		limit: Int!,
+		"""
+		Extra items to skip on top of `pageIndex` paging (default 0).
+		"""
+		offset: Int,
+		"""
+		Zero-based page number; multiplies `limit` to determine where to start (default 0).
+		"""
+		pageIndex: Int
+	): [Int!]!
 	"""
 	Fetch one page of timestamps in reverse order with a number of items up to a specified limit,
 	optionally offset by a specified amount. The page_index sets the number of pages to skip (defaults to 0).
@@ -1597,7 +2391,20 @@ type HistoryTimestamp {
 	For example, if page_rev(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
 	will be returned.
 	"""
-	pageRev(limit: Int!, offset: Int, pageIndex: Int): [Int!]!
+	pageRev(
+		"""
+		Maximum number of items to return on this page.
+		"""
+		limit: Int!,
+		"""
+		Extra items to skip on top of `pageIndex` paging (default 0).
+		"""
+		offset: Int,
+		"""
+		Zero-based page number; multiplies `limit` to determine where to start (default 0).
+		"""
+		pageIndex: Int
+	): [Int!]!
 }
 
 type IndexSpec {
@@ -1632,13 +2439,13 @@ input IndexSpecInput {
 
 input InputEdge {
 	"""
-	Source node.
+	Source node id (string or non-negative integer).
 	"""
-	src: String!
+	src: NodeId!
 	"""
-	Destination node.
+	Destination node id (string or non-negative integer).
 	"""
-	dst: String!
+	dst: NodeId!
 }
 
 """
@@ -1660,7 +2467,20 @@ type Intervals {
 	For example, if page(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
 	will be returned.
 	"""
-	page(limit: Int!, offset: Int, pageIndex: Int): [Int!]!
+	page(
+		"""
+		Maximum number of items to return on this page.
+		"""
+		limit: Int!,
+		"""
+		Extra items to skip on top of `pageIndex` paging (default 0).
+		"""
+		offset: Int,
+		"""
+		Zero-based page number; multiplies `limit` to determine where to start (default 0).
+		"""
+		pageIndex: Int
+	): [Int!]!
 	"""
 	Fetch one page of intervals between consecutive timestamps in reverse order with a number of items up to a specified limit,
 	optionally offset by a specified amount. The page_index sets the number of pages to skip (defaults to 0).
@@ -1668,7 +2488,20 @@ type Intervals {
 	For example, if page(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
 	will be returned.
 	"""
-	pageRev(limit: Int!, offset: Int, pageIndex: Int): [Int!]!
+	pageRev(
+		"""
+		Maximum number of items to return on this page.
+		"""
+		limit: Int!,
+		"""
+		Extra items to skip on top of `pageIndex` paging (default 0).
+		"""
+		offset: Int,
+		"""
+		Zero-based page number; multiplies `limit` to determine where to start (default 0).
+		"""
+		pageIndex: Int
+	): [Int!]!
 	"""
 	Compute the mean interval between consecutive timestamps. Returns None if fewer than 1 timestamp.
 	"""
@@ -1687,6 +2520,10 @@ type Intervals {
 	min: Int
 }
 
+"""
+Describes a single edge layer — its name and the per `(srcType, dstType)`
+edge schemas observed within it.
+"""
 type LayerSchema {
 	"""
 	Returns the name of the layer with this schema
@@ -1698,6 +2535,12 @@ type LayerSchema {
 	edges: [EdgeSchema!]!
 }
 
+"""
+Lightweight summary of a stored graph — its name, path, counts, and
+filesystem timestamps — served without deserializing the full graph.
+Useful for listing what's available on the server before committing to a
+full load.
+"""
 type MetaGraph {
 	"""
 	Returns the graph name.
@@ -1736,23 +2579,45 @@ type MetaGraph {
 	metadata: [Property!]!
 }
 
+"""
+Constant key/value metadata attached to an entity (node, edge, or graph).
+Metadata has no timeline — each key maps to exactly one value for the
+lifetime of the entity. Separate from `Properties`, which carries
+time-varying data.
+"""
 type Metadata {
 	"""
-	Get metadata value matching the specified key.
+	Look up a single metadata value by key. Returns null if no metadata with that
+	key exists.
 	"""
-	get(key: String!): Property
+	get(
+		"""
+		The metadata name.
+		"""
+		key: String!
+	): Property
 	"""
-	/// Check if the key is in the metadata.
+	Returns true if a metadata entry with the given key exists.
 	"""
-	contains(key: String!): Boolean!
+	contains(
+		"""
+		The metadata name to look up.
+		"""
+		key: String!
+	): Boolean!
 	"""
-	Return all metadata keys.
+	All metadata keys present on this entity.
 	"""
 	keys: [String!]!
 	"""
-	/// Return all metadata values.
+	All metadata values as `{key, value}` entries.
 	"""
-	values(keys: [String!]): [Property!]!
+	values(
+		"""
+		Optional whitelist. If provided, only metadata with these keys is returned; if omitted, every metadata entry is returned.
+		"""
+		keys: [String!]
+	): [Property!]!
 }
 
 type MutRoot {
@@ -1761,54 +2626,152 @@ type MutRoot {
 	"""
 	plugins: MutationPlugin!
 	"""
-	Delete graph from a path on the server.
-	"""
-	deleteGraph(path: String!): Boolean!
-	"""
-	Creates a new graph.
-	"""
-	newGraph(path: String!, graphType: GraphType!): Boolean!
-	"""
-	Move graph from a path path on the server to a new_path on the server.
-	
-	If namespace is not provided, it will be set to the current working directory.
-	This applies to both the graph namespace and new graph namespace.
-	"""
-	moveGraph(path: String!, newPath: String!): Boolean!
-	"""
-	Copy graph from a path path on the server to a new_path on the server.
-	
-	If namespace is not provided, it will be set to the current working directory.
-	This applies to both the graph namespace and new graph namespace.
-	"""
-	copyGraph(path: String!, newPath: String!): Boolean!
-	"""
-	Upload a graph file from a path on the client using GQL multipart uploading.
-	
-	Returns::
-	name of the new graph
-	"""
-	uploadGraph(path: String!, graph: Upload!, overwrite: Boolean!): String!
-	"""
-	Send graph bincode as base64 encoded string.
-	
-	Returns::
-	path of the new graph
-	"""
-	sendGraph(path: String!, graph: String!, overwrite: Boolean!): String!
-	"""
-	Returns a subgraph given a set of nodes from an existing graph in the server.
-	
-	Returns::
-	name of the new graph
-	"""
-	createSubgraph(parentPath: String!, nodes: [String!]!, newPath: String!, overwrite: Boolean!): String!
-	"""
-	(Experimental) Creates search index.
-	"""
-	createIndex(path: String!, indexSpec: IndexSpecInput, inRam: Boolean!): Boolean!
+	Permanently delete a stored graph from the server.
+	Requires WRITE on the graph and on its parent namespace.
+	"""
+	deleteGraph(
+		"""
+		Graph path relative to the root namespace.
+		"""
+		path: String!
+	): Boolean!
+	"""
+	Create a new empty graph at the given path. Errors if a graph already
+	exists there.
+	Requires WRITE on the parent namespace.
+	"""
+	newGraph(
+		"""
+		Destination path relative to the root namespace.
+		"""
+		path: String!,		graphType: GraphType!
+	): Boolean!
+	"""
+	Move a stored graph to a new path on the server (rename / relocate).
+	Atomic: copies first, then deletes the source.
+	Requires WRITE on the source graph and on both the source and
+	destination namespaces.
+	"""
+	moveGraph(
+		"""
+		Current graph path relative to the root namespace.
+		"""
+		path: String!,
+		"""
+		Destination path relative to the root namespace.
+		"""
+		newPath: String!,
+		"""
+		If true, allow replacing an existing graph at `newPath`; defaults to false.
+		"""
+		overwrite: Boolean
+	): Boolean!
+	"""
+	Duplicate a stored graph to a new path on the server. Source is
+	preserved.
+	Requires READ on the source graph and WRITE on the destination namespace.
+	"""
+	copyGraph(
+		"""
+		Source graph path relative to the root namespace.
+		"""
+		path: String!,
+		"""
+		Destination path relative to the root namespace.
+		"""
+		newPath: String!,
+		"""
+		If true, allow replacing an existing graph at `newPath`; defaults to false.
+		"""
+		overwrite: Boolean
+	): Boolean!
+	"""
+	Stream-upload a graph file using GraphQL multipart upload. The client
+	sends the file directly; the server stores it under `path`.
+	Requires WRITE on the destination namespace.
+	"""
+	uploadGraph(
+		"""
+		Destination path relative to the root namespace.
+		"""
+		path: String!,
+		"""
+		Multipart upload of the serialised graph file.
+		"""
+		graph: Upload!,
+		"""
+		If true, replace any graph already at `path`.
+		"""
+		overwrite: Boolean!
+	): String!
+	"""
+	Send a serialised graph as a base64-encoded string in the request
+	body. Use for smaller graphs where multipart upload is overkill.
+	Requires WRITE on the destination namespace.
+	"""
+	sendGraph(
+		"""
+		Destination path relative to the root namespace.
+		"""
+		path: String!,
+		"""
+		Base64-encoded bincode of the serialised graph.
+		"""
+		graph: String!,
+		"""
+		If true, replace any graph already at `path`.
+		"""
+		overwrite: Boolean!
+	): String!
+	"""
+	Persist a subgraph of an existing stored graph as a new graph. The
+	subgraph contains only the listed nodes and edges between them.
+	Requires READ on the parent graph and WRITE on the destination namespace.
+	"""
+	createSubgraph(
+		"""
+		Source graph path relative to the root namespace.
+		"""
+		parentPath: String!,
+		"""
+		Node ids to include in the subgraph.
+		"""
+		nodes: [NodeId!]!,
+		"""
+		Destination path relative to the root namespace.
+		"""
+		newPath: String!,
+		"""
+		If true, replace any graph already at `newPath`.
+		"""
+		overwrite: Boolean!
+	): String!
+	"""
+	(Experimental) Build a Tantivy search index for a stored graph so it
+	can be queried via `searchNodes` / `searchEdges`.
+	Requires WRITE on the graph.
+	"""
+	createIndex(
+		"""
+		Graph path relative to the root namespace.
+		"""
+		path: String!,
+		"""
+		Optional spec selecting which node/edge property fields to index. Omit to index a default set.
+		"""
+		indexSpec: IndexSpecInput,
+		"""
+		If true, build the index in memory (faster but lost on restart). If false, persist to disk.
+		"""
+		inRam: Boolean!
+	): Boolean!
 }
 
+"""
+Write-side handle for a single edge — returned from `addEdge` or
+`MutableGraph.edge`. Supports adding updates, deletions, and attaching
+or updating metadata.
+"""
 type MutableEdge {
 	"""
 	Use to check if adding the edge was successful.
@@ -1827,83 +2790,283 @@ type MutableEdge {
 	"""
 	dst: MutableNode!
 	"""
-	Mark the edge as deleted at time time.
-	"""
-	delete(time: Int!, layer: String): Boolean!
-	"""
-	Add metadata to the edge (errors if the value already exists).
-	
-	If this is called after add_edge, the layer is inherited from the add_edge and does not
-	need to be specified again.
-	"""
-	addMetadata(properties: [PropertyInput!]!, layer: String): Boolean!
-	"""
-	Update metadata of the edge (existing values are overwritten).
-	
-	If this is called after add_edge, the layer is inherited from the add_edge and does not
-	need to be specified again.
-	"""
-	updateMetadata(properties: [PropertyInput!]!, layer: String): Boolean!
-	"""
-	Add temporal property updates to the edge.
-	
-	If this is called after add_edge, the layer is inherited from the add_edge and does not
-	need to be specified again.
-	"""
-	addUpdates(time: Int!, properties: [PropertyInput!], layer: String): Boolean!
+	Mark this edge as deleted at the given time. Persistent graphs treat this
+	as a tombstone (the edge becomes invalid from `time` onwards); event
+	graphs simply log the deletion event.
+	"""
+	delete(
+		"""
+		Time of the deletion.
+		"""
+		time: TimeInput!,
+		"""
+		Optional layer name. If omitted, uses the layer the edge was originally added on (when called after `addEdge`).
+		"""
+		layer: String
+	): Boolean!
+	"""
+	Add metadata to this edge. Errors if any of the keys already exists —
+	use `updateMetadata` to overwrite. If this is called after `addEdge`,
+	the layer is inherited and does not need to be specified again.
+	"""
+	addMetadata(
+		"""
+		List of `{key, value}` pairs to set as metadata.
+		"""
+		properties: [PropertyInput!]!,
+		"""
+		Optional layer name; defaults to the inherited layer.
+		"""
+		layer: String
+	): Boolean!
+	"""
+	Update metadata of this edge, overwriting any existing values for the
+	given keys. If this is called after `addEdge`, the layer is inherited
+	and does not need to be specified again.
+	"""
+	updateMetadata(
+		"""
+		List of `{key, value}` pairs to upsert.
+		"""
+		properties: [PropertyInput!]!,
+		"""
+		Optional layer name; defaults to the inherited layer.
+		"""
+		layer: String
+	): Boolean!
+	"""
+	Append a property update to this edge at a specific time. If called
+	after `addEdge`, the layer is inherited and does not need to be
+	specified again.
+	"""
+	addUpdates(
+		"""
+		Time of the update.
+		"""
+		time: TimeInput!,
+		"""
+		Optional `{key, value}` pairs attached to the event.
+		"""
+		properties: [PropertyInput!],
+		"""
+		Optional layer name; defaults to the inherited layer.
+		"""
+		layer: String
+	): Boolean!
 }
 
+"""
+Write-enabled handle for a graph. Obtained by calling `updateGraph(path)`
+on the root query with a path you have write permission for. Supports
+adding nodes and edges (individually or in batches), attaching
+properties/metadata, and looking up mutable `node`/`edge` handles. Use the
+read-only `graph(path)` resolver for queries.
+"""
 type MutableGraph {
 	"""
-	Get the non-mutable graph.
-	"""
-	graph: Graph!
-	"""
-	Get mutable existing node.
-	"""
-	node(name: String!): MutableNode
-	"""
-	Add a new node or add updates to an existing node.
-	"""
-	addNode(time: Int!, name: String!, properties: [PropertyInput!], nodeType: String): MutableNode!
-	"""
-	Create a new node or fail if it already exists.
-	"""
-	createNode(time: Int!, name: String!, properties: [PropertyInput!], nodeType: String): MutableNode!
-	"""
-	Add a batch of nodes.
-	"""
-	addNodes(nodes: [NodeAddition!]!): Boolean!
-	"""
-	Get a mutable existing edge.
-	"""
-	edge(src: String!, dst: String!): MutableEdge
-	"""
-	Add a new edge or add updates to an existing edge.
-	"""
-	addEdge(time: Int!, src: String!, dst: String!, properties: [PropertyInput!], layer: String): MutableEdge!
-	"""
-	Add a batch of edges.
-	"""
-	addEdges(edges: [EdgeAddition!]!): Boolean!
-	"""
-	Mark an edge as deleted (creates the edge if it did not exist).
-	"""
-	deleteEdge(time: Int!, src: String!, dst: String!, layer: String): MutableEdge!
-	"""
-	Add temporal properties to graph.
-	"""
-	addProperties(t: Int!, properties: [PropertyInput!]!): Boolean!
-	"""
-	Add metadata to graph (errors if the property already exists).
-	"""
-	addMetadata(properties: [PropertyInput!]!): Boolean!
-	"""
-	Update metadata of the graph (overwrites existing values).
-	"""
-	updateMetadata(properties: [PropertyInput!]!): Boolean!
+	Read-only view of this graph — identical to what you'd get from
+	`graph(path:)` on the query root. Use this when you want to compose
+	queries on the graph you've just mutated. `graphType` lets you
+	re-interpret the graph at query time (see `graph(path:)` for
+	semantics); defaults to the stored graph's native type.
+	"""
+	graph(
+		"""
+		Optional override for graph semantics — `EVENT` treats every update as a point-in-time event, `PERSISTENT` carries values forward until overwritten or deleted. Defaults to the stored graph's native type.
+		"""
+		graphType: GraphType
+	): Graph!
+	"""
+	Look up an existing node for mutation. Returns null if the node doesn't
+	exist; use `addNode` or `createNode` to create one.
+	"""
+	node(
+		"""
+		Node id.
+		"""
+		name: NodeId!
+	): MutableNode
+	"""
+	Add a new node or append an update to an existing one. Upsert semantics:
+	no error if the node already exists — properties and type are merged.
+	"""
+	addNode(
+		"""
+		Time of the event.
+		"""
+		time: TimeInput!,
+		"""
+		Node id.
+		"""
+		name: NodeId!,
+		"""
+		Optional property updates attached to this event.
+		"""
+		properties: [PropertyInput!],
+		"""
+		Optional node type to assign. If provided, sets the node's type at this event.
+		"""
+		nodeType: String,
+		"""
+		Optional layer name. If omitted, the default layer is used.
+		"""
+		layer: String
+	): MutableNode!
+	"""
+	Create a new node or fail if it already exists. Strict alternative to
+	`addNode` — use this when you want to detect collisions.
+	"""
+	createNode(
+		"""
+		Time of the create event.
+		"""
+		time: TimeInput!,
+		"""
+		Node id.
+		"""
+		name: NodeId!,
+		"""
+		Optional property updates attached to this event.
+		"""
+		properties: [PropertyInput!],
+		"""
+		Optional node type to assign. If provided, sets the node's type at this event.
+		"""
+		nodeType: String,
+		"""
+		Optional layer name. If omitted, the default layer is used.
+		"""
+		layer: String
+	): MutableNode!
+	"""
+	Batch-add multiple nodes in one call. For each `NodeAddition`, applies every
+	update it carries (time/properties pairs), then optionally sets its node type
+	and adds any metadata. On partial failure, returns a `BatchFailures` error
+	describing which entries failed and why; otherwise returns true.
+	"""
+	addNodes(
+		"""
+		List of `NodeAddition` inputs, each specifying a node's name, optional type, layer, per-timestamp updates, and metadata.
+		"""
+		nodes: [NodeAddition!]!
+	): Boolean!
+	"""
+	Look up an existing edge for mutation. Returns null if no such edge exists.
+	"""
+	edge(
+		"""
+		Source node id.
+		"""
+		src: NodeId!,
+		"""
+		Destination node id.
+		"""
+		dst: NodeId!
+	): MutableEdge
+	"""
+	Add a new edge or append an update to an existing one. Upsert semantics:
+	safe to call on an edge that already exists — creates missing endpoints if
+	needed.
+	"""
+	addEdge(
+		"""
+		Time of the event.
+		"""
+		time: TimeInput!,
+		"""
+		Source node id.
+		"""
+		src: NodeId!,
+		"""
+		Destination node id.
+		"""
+		dst: NodeId!,
+		"""
+		Optional property updates attached to this event.
+		"""
+		properties: [PropertyInput!],
+		"""
+		Optional layer name. If omitted, the default layer is used.
+		"""
+		layer: String
+	): MutableEdge!
+	"""
+	Batch-add multiple edges in one call. For each `EdgeAddition`, applies every
+	update it carries, then adds any metadata. On partial failure, returns a
+	`BatchFailures` error describing which entries failed; otherwise returns
+	true.
+	"""
+	addEdges(
+		"""
+		List of `EdgeAddition` inputs, each specifying an edge's `src`, `dst`, optional layer, per-timestamp updates, and metadata.
+		"""
+		edges: [EdgeAddition!]!
+	): Boolean!
+	"""
+	Mark an edge as deleted at the given time. Persistent graphs treat this
+	as a tombstone (the edge becomes invalid from `time` onwards); event
+	graphs simply log the deletion event. Creates the edge first if it did
+	not exist.
+	"""
+	deleteEdge(
+		"""
+		Time of the deletion.
+		"""
+		time: TimeInput!,
+		"""
+		Source node id.
+		"""
+		src: NodeId!,
+		"""
+		Destination node id.
+		"""
+		dst: NodeId!,
+		"""
+		Optional layer name. If omitted, the default layer is used.
+		"""
+		layer: String
+	): MutableEdge!
+	"""
+	Add temporal properties to the graph itself (not a node or edge). Each
+	call records a property update at `t`.
+	"""
+	addProperties(
+		"""
+		Time of the update.
+		"""
+		t: TimeInput!,
+		"""
+		List of `{key, value}` pairs to set.
+		"""
+		properties: [PropertyInput!]!
+	): Boolean!
+	"""
+	Add metadata to the graph itself. Errors if any of the keys already
+	exists — use `updateMetadata` to overwrite.
+	"""
+	addMetadata(
+		"""
+		List of `{key, value}` pairs to set as metadata.
+		"""
+		properties: [PropertyInput!]!
+	): Boolean!
+	"""
+	Update metadata of the graph itself, overwriting any existing values for
+	the given keys.
+	"""
+	updateMetadata(
+		"""
+		List of `{key, value}` pairs to upsert.
+		"""
+		properties: [PropertyInput!]!
+	): Boolean!
 }
 
+"""
+Write-side handle for a single node — returned from `addNode`, `createNode`,
+or `MutableGraph.node`. Supports adding updates, setting node type, and
+attaching or updating metadata.
+"""
 type MutableNode {
 	"""
 	Use to check if adding the node was successful.
@@ -1914,32 +3077,90 @@ type MutableNode {
 	"""
 	node: Node!
 	"""
-	Add metadata to the node (errors if the property already exists).
-	"""
-	addMetadata(properties: [PropertyInput!]!): Boolean!
-	"""
-	Set the node type (errors if the node already has a non-default type).
-	"""
-	setNodeType(newType: String!): Boolean!
-	"""
-	Update metadata of the node (overwrites existing property values).
-	"""
-	updateMetadata(properties: [PropertyInput!]!): Boolean!
-	"""
-	Add temporal property updates to the node.
-	"""
-	addUpdates(time: Int!, properties: [PropertyInput!]): Boolean!
+	Add metadata to this node. Errors if any of the keys already exists —
+	use `updateMetadata` to overwrite.
+	"""
+	addMetadata(
+		"""
+		List of `{key, value}` pairs to set as metadata.
+		"""
+		properties: [PropertyInput!]!
+	): Boolean!
+	"""
+	Set this node's type. Errors if the node already has a non-default
+	type and you're trying to change it.
+	"""
+	setNodeType(
+		"""
+		Node-type name to assign.
+		"""
+		newType: String!
+	): Boolean!
+	"""
+	Update metadata of this node, overwriting any existing values for the
+	given keys.
+	"""
+	updateMetadata(
+		"""
+		List of `{key, value}` pairs to upsert.
+		"""
+		properties: [PropertyInput!]!
+	): Boolean!
+	"""
+	Append a property update to this node at a specific time.
+	"""
+	addUpdates(
+		"""
+		Time of the update.
+		"""
+		time: TimeInput!,
+		"""
+		Optional `{key, value}` pairs attached to the event.
+		"""
+		properties: [PropertyInput!],
+		"""
+		Optional layer name. If omitted, the default layer is used.
+		"""
+		layer: String
+	): Boolean!
 }
 
 type MutationPlugin {
 	NoOps: String!
 }
 
+"""
+A directory-like container for graphs and nested namespaces. Graphs are
+addressed by path (e.g. `"team/project/graph"`), and every segment except
+the last is a namespace. Use to browse what's stored on the server without
+loading any graph data.
+"""
 type Namespace {
+	"""
+	Graphs directly inside this namespace (excludes graphs in nested
+	namespaces). Filtered by the caller's permissions — only graphs the
+	caller is allowed to see are returned.
+	"""
 	graphs: CollectionOfMetaGraph!
+	"""
+	Path of this namespace relative to the root namespace. Empty string for
+	the root namespace itself.
+	"""
 	path: String!
+	"""
+	Parent namespace, or null at the root.
+	"""
 	parent: Namespace
+	"""
+	Sub-namespaces directly inside this one (one level down, not recursive).
+	Filtered by permissions.
+	"""
 	children: CollectionOfNamespace!
+	"""
+	Everything in this namespace — sub-namespaces and graphs — as a single
+	heterogeneous collection. Sub-namespaces are listed before graphs.
+	Filtered by permissions.
+	"""
 	items: CollectionOfNamespacedItem!
 }
 
@@ -1950,9 +3171,10 @@ Raphtory graph node.
 """
 type Node {
 	"""
-	Returns the unique id of the node.
+	Returns the unique id of the node — `String` for string-indexed
+	graphs, non-negative `Int` for integer-indexed graphs.
 	"""
-	id: String!
+	id: NodeId!
 	"""
 	Returns the name of the node.
 	"""
@@ -1964,19 +3186,39 @@ type Node {
 	"""
 	Return a view of node containing all layers specified.
 	"""
-	layers(names: [String!]!): Node!
+	layers(
+		"""
+		Layer names to include.
+		"""
+		names: [String!]!
+	): Node!
 	"""
 	Returns a collection containing nodes belonging to all layers except the excluded list of layers.
 	"""
-	excludeLayers(names: [String!]!): Node!
+	excludeLayers(
+		"""
+		Layer names to exclude.
+		"""
+		names: [String!]!
+	): Node!
 	"""
 	Returns a collection containing nodes belonging to the specified layer.
 	"""
-	layer(name: String!): Node!
+	layer(
+		"""
+		Layer name to include.
+		"""
+		name: String!
+	): Node!
 	"""
 	Returns a collection containing nodes belonging to all layers except the excluded layer.
 	"""
-	excludeLayer(name: String!): Node!
+	excludeLayer(
+		"""
+		Layer name to exclude.
+		"""
+		name: String!
+	): Node!
 	"""
 	Creates a WindowSet with the specified window size and optional step using a rolling window.
 	
@@ -1988,7 +3230,20 @@ type Node {
 	Note that passing a step larger than window while alignment_unit is not "Unaligned" may lead to some entries appearing before
 	the start of the first window and/or after the end of the last window (i.e. not included in any window).
 	"""
-	rolling(window: WindowDuration!, step: WindowDuration, alignmentUnit: AlignmentUnit): NodeWindowSet!
+	rolling(
+		"""
+		Width of each window. Pass either `{epoch: <ms>}` for a discrete number of milliseconds (e.g. `{epoch: 1000}` for 1 second), or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}` or `{duration: 2 hours and 30 minutes}`).
+		"""
+		window: WindowDuration!,
+		"""
+		Optional gap between the start of one window and the start of the next. Accepts the same `{epoch: <ms>}` or `{duration: <text>}` values as `window`. Defaults to `window` — i.e. windows touch end-to-end with no overlap and no gap.
+		"""
+		step: WindowDuration,
+		"""
+		Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step` (or `window` if no step is set).
+		"""
+		alignmentUnit: AlignmentUnit
+	): NodeWindowSet!
 	"""
 	Creates a WindowSet with the specified step size using an expanding window.
 	
@@ -1998,15 +3253,38 @@ type Node {
 	If unspecified (i.e. by default), alignment is done on the smallest unit of time in the step.
 	e.g. "1 month and 1 day" will align at the start of the day.
 	"""
-	expanding(step: WindowDuration!, alignmentUnit: AlignmentUnit): NodeWindowSet!
+	expanding(
+		"""
+		How much the window grows by on each step. Pass either `{epoch: <ms>}` for a discrete number of milliseconds, or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}`).
+		"""
+		step: WindowDuration!,
+		"""
+		Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step`.
+		"""
+		alignmentUnit: AlignmentUnit
+	): NodeWindowSet!
 	"""
 	Create a view of the node including all events between the specified start (inclusive) and end (exclusive).
 	"""
-	window(start: TimeInput!, end: TimeInput!): Node!
+	window(
+		"""
+		Inclusive lower bound.
+		"""
+		start: TimeInput!,
+		"""
+		Exclusive upper bound.
+		"""
+		end: TimeInput!
+	): Node!
 	"""
 	Create a view of the node including all events at a specified time.
 	"""
-	at(time: TimeInput!): Node!
+	at(
+		"""
+		Instant to pin the view to.
+		"""
+		time: TimeInput!
+	): Node!
 	"""
 	Create a view of the node including all events at the latest time.
 	"""
@@ -2014,7 +3292,12 @@ type Node {
 	"""
 	Create a view of the node including all events that are valid at the specified time.
 	"""
-	snapshotAt(time: TimeInput!): Node!
+	snapshotAt(
+		"""
+		Instant at which entities must be valid.
+		"""
+		time: TimeInput!
+	): Node!
 	"""
 	Create a view of the node including all events that are valid at the latest time.
 	"""
@@ -2022,23 +3305,52 @@ type Node {
 	"""
 	Create a view of the node including all events before specified end time (exclusive).
 	"""
-	before(time: TimeInput!): Node!
+	before(
+		"""
+		Exclusive upper bound.
+		"""
+		time: TimeInput!
+	): Node!
 	"""
 	Create a view of the node including all events after the specified start time (exclusive).
 	"""
-	after(time: TimeInput!): Node!
+	after(
+		"""
+		Exclusive lower bound.
+		"""
+		time: TimeInput!
+	): Node!
 	"""
 	Shrink a Window to a specified start and end time, if these are earlier and later than the current start and end respectively.
 	"""
-	shrinkWindow(start: TimeInput!, end: TimeInput!): Node!
+	shrinkWindow(
+		"""
+		Proposed new start (TimeInput); ignored if it would widen the window.
+		"""
+		start: TimeInput!,
+		"""
+		Proposed new end (TimeInput); ignored if it would widen the window.
+		"""
+		end: TimeInput!
+	): Node!
 	"""
 	Set the start of the window to the larger of a specified start time and self.start().
 	"""
-	shrinkStart(start: TimeInput!): Node!
+	shrinkStart(
+		"""
+		Proposed new start (TimeInput); ignored if it would widen the window.
+		"""
+		start: TimeInput!
+	): Node!
 	"""
 	Set the end of the window to the smaller of a specified end and self.end().
 	"""
-	shrinkEnd(end: TimeInput!): Node!
+	shrinkEnd(
+		"""
+		Proposed new end (TimeInput); ignored if it would widen the window.
+		"""
+		end: TimeInput!
+	): Node!
 	applyViews(views: [NodeViewCollection!]!): Node!
 	"""
 	Returns the earliest time that the node exists.
@@ -2131,9 +3443,9 @@ type Node {
 
 input NodeAddition {
 	"""
-	Name.
+	Node id (string or non-negative integer).
 	"""
-	name: String!
+	name: NodeId!
 	"""
 	Node type.
 	"""
@@ -2146,6 +3458,10 @@ input NodeAddition {
 	Updates.
 	"""
 	updates: [TemporalPropertyInput!]
+	"""
+	Layer.
+	"""
+	layer: String
 }
 
 enum NodeField {
@@ -2340,6 +3656,13 @@ input NodeFilter @oneOf {
 	isActive: Boolean
 }
 
+"""
+Identifier for a node — either a string (`"alice"`) or a non-negative
+integer (`42`). Use whichever form matches how the graph was indexed
+when nodes were added.
+"""
+scalar NodeId
+
 """
 Restricts node evaluation to one or more layers and applies a nested `NodeFilter`.
 
@@ -2356,12 +3679,27 @@ input NodeLayersExpr {
 	expr: NodeFilter!
 }
 
+"""
+Describes nodes of a specific type in a graph — its property keys and
+observed value types (and, for string-valued properties, the set of
+distinct values seen). One `NodeSchema` per node type.
+"""
 type NodeSchema {
+	"""
+	The node type this schema describes (e.g. `"person"`, `"org"`).
+	Falls back to the default node type for untyped nodes.
+	"""
 	typeName: String!
 	"""
-	Returns the list of property schemas for this node
+	Property schemas seen on nodes of this type — one entry per property key
+	ever set on a node of this type, with its observed `PropertyType` and (for
+	string-valued properties) the set of distinct values.
 	"""
 	properties: [PropertySchema!]!
+	"""
+	Metadata schemas seen on nodes of this type — like `properties`, but
+	covering metadata fields rather than temporal properties.
+	"""
 	metadata: [PropertySchema!]!
 }
 
@@ -2497,7 +3835,16 @@ input NodeWindowExpr {
 	expr: NodeFilter!
 }
 
+"""
+A lazy sequence of per-window views of a single node, produced by
+`node.rolling` / `node.expanding`. Each entry is the node as it exists in
+that window.
+"""
 type NodeWindowSet {
+	"""
+	Number of windows in this set. Materialising all windows is expensive for
+	large graphs — prefer `page` over `list` when iterating.
+	"""
 	count: Int!
 	"""
 	Fetch one page with a number of items up to a specified limit, optionally offset by a specified amount.
@@ -2506,10 +3853,32 @@ type NodeWindowSet {
 	For example, if page(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
 	will be returned.
 	"""
-	page(limit: Int!, offset: Int, pageIndex: Int): [Node!]!
+	page(
+		"""
+		Maximum number of items to return on this page.
+		"""
+		limit: Int!,
+		"""
+		Extra items to skip on top of `pageIndex` paging (default 0).
+		"""
+		offset: Int,
+		"""
+		Zero-based page number; multiplies `limit` to determine where to start (default 0).
+		"""
+		pageIndex: Int
+	): [Node!]!
+	"""
+	Materialise every window as a list. Rejected by the server when bulk list
+	endpoints are disabled; use `page` for paginated access instead.
+	"""
 	list: [Node!]!
 }
 
+"""
+A lazy collection of nodes from a graph view. Supports all the same view
+transforms as `Graph` (window, layer, filter, ...) plus pagination and
+sorting. Iterated via `list` / `page` / `ids` / `count`.
+"""
 type Nodes {
 	"""
 	Return a view of the nodes containing only the default edge layer.
@@ -2518,19 +3887,39 @@ type Nodes {
 	"""
 	Return a view of the nodes containing all layers specified.
 	"""
-	layers(names: [String!]!): Nodes!
+	layers(
+		"""
+		Layer names to include.
+		"""
+		names: [String!]!
+	): Nodes!
 	"""
 	Return a view of the nodes containing all layers except those specified.
 	"""
-	excludeLayers(names: [String!]!): Nodes!
+	excludeLayers(
+		"""
+		Layer names to exclude.
+		"""
+		names: [String!]!
+	): Nodes!
 	"""
 	Return a view of the nodes containing the specified layer.
 	"""
-	layer(name: String!): Nodes!
+	layer(
+		"""
+		Layer name to include.
+		"""
+		name: String!
+	): Nodes!
 	"""
 	Return a view of the nodes containing all layers except those specified.
 	"""
-	excludeLayer(name: String!): Nodes!
+	excludeLayer(
+		"""
+		Layer name to exclude.
+		"""
+		name: String!
+	): Nodes!
 	"""
 	Creates a WindowSet with the specified window size and optional step using a rolling window.
 	
@@ -2542,7 +3931,20 @@ type Nodes {
 	Note that passing a step larger than window while alignment_unit is not "Unaligned" may lead to some entries appearing before
 	the start of the first window and/or after the end of the last window (i.e. not included in any window).
 	"""
-	rolling(window: WindowDuration!, step: WindowDuration, alignmentUnit: AlignmentUnit): NodesWindowSet!
+	rolling(
+		"""
+		Width of each window. Pass either `{epoch: <ms>}` for a discrete number of milliseconds (e.g. `{epoch: 1000}` for 1 second), or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}` or `{duration: 2 hours and 30 minutes}`).
+		"""
+		window: WindowDuration!,
+		"""
+		Optional gap between the start of one window and the start of the next. Accepts the same `{epoch: <ms>}` or `{duration: <text>}` values as `window`. Defaults to `window` — i.e. windows touch end-to-end with no overlap and no gap.
+		"""
+		step: WindowDuration,
+		"""
+		Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step` (or `window` if no step is set).
+		"""
+		alignmentUnit: AlignmentUnit
+	): NodesWindowSet!
 	"""
 	Creates a WindowSet with the specified step size using an expanding window.
 	
@@ -2552,15 +3954,38 @@ type Nodes {
 	If unspecified (i.e. by default), alignment is done on the smallest unit of time in the step.
 	e.g. "1 month and 1 day" will align at the start of the day.
 	"""
-	expanding(step: WindowDuration!, alignmentUnit: AlignmentUnit): NodesWindowSet!
+	expanding(
+		"""
+		How much the window grows by on each step. Pass either `{epoch: <ms>}` for a discrete number of milliseconds, or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}`).
+		"""
+		step: WindowDuration!,
+		"""
+		Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step`.
+		"""
+		alignmentUnit: AlignmentUnit
+	): NodesWindowSet!
 	"""
 	Create a view of the node including all events between the specified start (inclusive) and end (exclusive).
 	"""
-	window(start: TimeInput!, end: TimeInput!): Nodes!
+	window(
+		"""
+		Inclusive lower bound.
+		"""
+		start: TimeInput!,
+		"""
+		Exclusive upper bound.
+		"""
+		end: TimeInput!
+	): Nodes!
 	"""
 	Create a view of the nodes including all events at a specified time.
 	"""
-	at(time: TimeInput!): Nodes!
+	at(
+		"""
+		Instant to pin the view to.
+		"""
+		time: TimeInput!
+	): Nodes!
 	"""
 	Create a view of the nodes including all events at the latest time.
 	"""
@@ -2568,7 +3993,12 @@ type Nodes {
 	"""
 	Create a view of the nodes including all events that are valid at the specified time.
 	"""
-	snapshotAt(time: TimeInput!): Nodes!
+	snapshotAt(
+		"""
+		Instant at which entities must be valid.
+		"""
+		time: TimeInput!
+	): Nodes!
 	"""
 	Create a view of the nodes including all events that are valid at the latest time.
 	"""
@@ -2576,29 +4006,82 @@ type Nodes {
 	"""
 	Create a view of the nodes including all events before specified end time (exclusive).
 	"""
-	before(time: TimeInput!): Nodes!
+	before(
+		"""
+		Exclusive upper bound.
+		"""
+		time: TimeInput!
+	): Nodes!
 	"""
 	Create a view of the nodes including all events after the specified start time (exclusive).
 	"""
-	after(time: TimeInput!): Nodes!
+	after(
+		"""
+		Exclusive lower bound.
+		"""
+		time: TimeInput!
+	): Nodes!
 	"""
 	Shrink both the start and end of the window.
 	"""
-	shrinkWindow(start: TimeInput!, end: TimeInput!): Nodes!
+	shrinkWindow(
+		"""
+		Proposed new start (TimeInput); ignored if it would widen the window.
+		"""
+		start: TimeInput!,
+		"""
+		Proposed new end (TimeInput); ignored if it would widen the window.
+		"""
+		end: TimeInput!
+	): Nodes!
 	"""
 	Set the start of the window to the larger of a specified start time and self.start().
 	"""
-	shrinkStart(start: TimeInput!): Nodes!
+	shrinkStart(
+		"""
+		Proposed new start (TimeInput); ignored if it would widen the window.
+		"""
+		start: TimeInput!
+	): Nodes!
 	"""
 	Set the end of the window to the smaller of a specified end and self.end().
 	"""
-	shrinkEnd(end: TimeInput!): Nodes!
+	shrinkEnd(
+		"""
+		Proposed new end (TimeInput); ignored if it would widen the window.
+		"""
+		end: TimeInput!
+	): Nodes!
 	"""
 	Filter nodes by node type.
 	"""
-	typeFilter(nodeTypes: [String!]!): Nodes!
-	applyViews(views: [NodesViewCollection!]!): Nodes!
-	sorted(sortBys: [NodeSortBy!]!): Nodes!
+	typeFilter(
+		"""
+		Node-type names to keep.
+		"""
+		nodeTypes: [String!]!
+	): Nodes!
+	"""
+	Apply a list of views in the given order and return the resulting nodes
+	collection. Lets callers compose window, layer, filter, and snapshot
+	operations in a single call.
+	"""
+	applyViews(
+		"""
+		Ordered list of view operations; each entry is a one-of variant (`window`, `layer`, `filter`, etc.) applied to the running result.
+		"""
+		views: [NodesViewCollection!]!
+	): Nodes!
+	"""
+	Sort the nodes. Multiple criteria are applied lexicographically (ties on the
+	first key break to the second, etc.).
+	"""
+	sorted(
+		"""
+		Ordered list of sort keys. Each entry chooses exactly one of `id` / `time` / `property`, with an optional `reverse: true` to flip order.
+		"""
+		sortBys: [NodeSortBy!]!
+	): Nodes!
 	"""
 	Returns the start time of the window. Errors if there is no window.
 	"""
@@ -2607,6 +4090,9 @@ type Nodes {
 	Returns the end time of the window. Errors if there is no window.
 	"""
 	end: EventTime!
+	"""
+	Number of nodes in the current view.
+	"""
 	count: Int!
 	"""
 	Fetch one page with a number of items up to a specified limit, optionally offset by a specified amount.
@@ -2615,20 +4101,78 @@ type Nodes {
 	For example, if page(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
 	will be returned.
 	"""
-	page(limit: Int!, offset: Int, pageIndex: Int): [Node!]!
+	page(
+		"""
+		Maximum number of items to return on this page.
+		"""
+		limit: Int!,
+		"""
+		Extra items to skip on top of `pageIndex` paging (default 0).
+		"""
+		offset: Int,
+		"""
+		Zero-based page number; multiplies `limit` to determine where to start (default 0).
+		"""
+		pageIndex: Int
+	): [Node!]!
+	"""
+	Materialise every node in the view. Rejected by the server when bulk list
+	endpoints are disabled; use `page` for paginated access instead.
+	"""
 	list: [Node!]!
 	"""
-	Returns a view of the node ids.
+	Every node's id (name) as a flat list of strings. Rejected by the server when
+	bulk list endpoints are disabled.
 	"""
 	ids: [String!]!
 	"""
-	Returns a filtered view that applies to list down the chain
-	"""
-	filter(expr: NodeFilter!): Nodes!
+	Narrow the collection to nodes matching `expr`. The filter sticks to the
+	returned view — every subsequent traversal through these nodes (their
+	neighbours, edges, properties) continues to see the filtered scope.
+	
+	Useful when you want one scoping rule to apply across the whole query.
+	E.g. restricting everything to a specific week:
+	
+	```text
+	nodes { filter(expr: {window: {start: 1234, end: 5678}}) {
+	list { neighbours { list { name } } }   # neighbours still windowed
+	} }
+	```
+	
+	Contrast with `select`, which applies here and is not carried through.
 	"""
-	Returns filtered list of nodes
+	filter(
+		"""
+		Composite node filter (by name, property, type, etc.).
+		"""
+		expr: NodeFilter!
+	): Nodes!
 	"""
-	select(expr: NodeFilter!): Nodes!
+	Narrow the collection to nodes matching `expr`, but only at this step —
+	subsequent traversals out of these nodes see the unfiltered graph again.
+	
+	Useful when you want different scopes at different hops. E.g. nodes
+	active on Monday, then their neighbours active on Tuesday, then *those*
+	neighbours active on Wednesday:
+	
+	```text
+	nodes { select(expr: {window: {...monday...}}) {
+	list { neighbours { select(expr: {window: {...tuesday...}}) {
+	list { neighbours { select(expr: {window: {...wednesday...}}) {
+	list { name }
+	} } }
+	} } }
+	} }
+	```
+	
+	Contrast with `filter`, which persists the scope through subsequent ops.
+	"""
+	select(
+		"""
+		Composite node filter (by name, property, type, etc.).
+		"""
+		expr: NodeFilter!
+	): Nodes!
 }
 
 input NodesViewCollection @oneOf {
@@ -2698,7 +4242,16 @@ input NodesViewCollection @oneOf {
 	typeFilter: [String!]
 }
 
+"""
+A lazy sequence of per-window node collections, produced by
+`nodes.rolling` / `nodes.expanding`. Each entry is a `Nodes` collection
+as it exists in that window.
+"""
 type NodesWindowSet {
+	"""
+	Number of windows in this set. Materialising all windows is expensive for
+	large graphs — prefer `page` over `list` when iterating.
+	"""
 	count: Int!
 	"""
 	Fetch one page with a number of items up to a specified limit, optionally offset by a specified amount.
@@ -2707,7 +4260,24 @@ type NodesWindowSet {
 	For example, if page(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
 	will be returned.
 	"""
-	page(limit: Int!, offset: Int, pageIndex: Int): [Nodes!]!
+	page(
+		"""
+		Maximum number of items to return on this page.
+		"""
+		limit: Int!,
+		"""
+		Extra items to skip on top of `pageIndex` paging (default 0).
+		"""
+		offset: Int,
+		"""
+		Zero-based page number; multiplies `limit` to determine where to start (default 0).
+		"""
+		pageIndex: Int
+	): [Nodes!]!
+	"""
+	Materialise every window as a list. Rejected by the server when bulk list
+	endpoints are disabled; use `page` for paginated access instead.
+	"""
 	list: [Nodes!]!
 }
 
@@ -2738,23 +4308,49 @@ type PagerankOutput {
 	rank: Float!
 }
 
+"""
+A collection of nodes anchored to a source node — the result of traversals
+like `node.neighbours`, `inNeighbours`, or `outNeighbours`. Supports all
+the usual view transforms (window, layer, filter, ...) and can be chained
+to walk further hops.
+"""
 type PathFromNode {
 	"""
 	Returns a view of PathFromNode containing the specified layer, errors if the layer does not exist.
 	"""
-	layers(names: [String!]!): PathFromNode!
+	layers(
+		"""
+		Layer names to include.
+		"""
+		names: [String!]!
+	): PathFromNode!
 	"""
 	Return a view of PathFromNode containing all layers except the specified excluded layers, errors if any of the layers do not exist.
 	"""
-	excludeLayers(names: [String!]!): PathFromNode!
+	excludeLayers(
+		"""
+		Layer names to exclude.
+		"""
+		names: [String!]!
+	): PathFromNode!
 	"""
 	Return a view of PathFromNode containing the layer specified layer, errors if the layer does not exist.
 	"""
-	layer(name: String!): PathFromNode!
+	layer(
+		"""
+		Layer name to include.
+		"""
+		name: String!
+	): PathFromNode!
 	"""
 	Return a view of PathFromNode containing all layers except the specified excluded layers, errors if any of the layers do not exist.
 	"""
-	excludeLayer(name: String!): PathFromNode!
+	excludeLayer(
+		"""
+		Layer name to exclude.
+		"""
+		name: String!
+	): PathFromNode!
 	"""
 	Creates a WindowSet with the given window size and optional step using a rolling window.
 	
@@ -2766,7 +4362,20 @@ type PathFromNode {
 	Note that passing a step larger than window while alignment_unit is not "Unaligned" may lead to some entries appearing before
 	the start of the first window and/or after the end of the last window (i.e. not included in any window).
 	"""
-	rolling(window: WindowDuration!, step: WindowDuration, alignmentUnit: AlignmentUnit): PathFromNodeWindowSet!
+	rolling(
+		"""
+		Width of each window. Pass either `{epoch: <ms>}` for a discrete number of milliseconds (e.g. `{epoch: 1000}` for 1 second), or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}` or `{duration: 2 hours and 30 minutes}`).
+		"""
+		window: WindowDuration!,
+		"""
+		Optional gap between the start of one window and the start of the next. Accepts the same `{epoch: <ms>}` or `{duration: <text>}` values as `window`. Defaults to `window` — i.e. windows touch end-to-end with no overlap and no gap.
+		"""
+		step: WindowDuration,
+		"""
+		Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step` (or `window` if no step is set).
+		"""
+		alignmentUnit: AlignmentUnit
+	): PathFromNodeWindowSet!
 	"""
 	Creates a WindowSet with the given step size using an expanding window.
 	
@@ -2776,15 +4385,38 @@ type PathFromNode {
 	If unspecified (i.e. by default), alignment is done on the smallest unit of time in the step.
 	e.g. "1 month and 1 day" will align at the start of the day.
 	"""
-	expanding(step: WindowDuration!, alignmentUnit: AlignmentUnit): PathFromNodeWindowSet!
+	expanding(
+		"""
+		How much the window grows by on each step. Pass either `{epoch: <ms>}` for a discrete number of milliseconds, or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}`).
+		"""
+		step: WindowDuration!,
+		"""
+		Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step`.
+		"""
+		alignmentUnit: AlignmentUnit
+	): PathFromNodeWindowSet!
 	"""
 	Create a view of the PathFromNode including all events between a specified start (inclusive) and end (exclusive).
 	"""
-	window(start: TimeInput!, end: TimeInput!): PathFromNode!
+	window(
+		"""
+		Inclusive lower bound.
+		"""
+		start: TimeInput!,
+		"""
+		Exclusive upper bound.
+		"""
+		end: TimeInput!
+	): PathFromNode!
 	"""
 	Create a view of the PathFromNode including all events at time.
 	"""
-	at(time: TimeInput!): PathFromNode!
+	at(
+		"""
+		Instant to pin the view to.
+		"""
+		time: TimeInput!
+	): PathFromNode!
 	"""
 	Create a view of the PathFromNode including all events that are valid at the latest time.
 	"""
@@ -2792,7 +4424,12 @@ type PathFromNode {
 	"""
 	Create a view of the PathFromNode including all events that are valid at the specified time.
 	"""
-	snapshotAt(time: TimeInput!): PathFromNode!
+	snapshotAt(
+		"""
+		Instant at which entities must be valid.
+		"""
+		time: TimeInput!
+	): PathFromNode!
 	"""
 	Create a view of the PathFromNode including all events at the latest time.
 	"""
@@ -2800,27 +4437,61 @@ type PathFromNode {
 	"""
 	Create a view of the PathFromNode including all events before the specified end (exclusive).
 	"""
-	before(time: TimeInput!): PathFromNode!
+	before(
+		"""
+		Exclusive upper bound.
+		"""
+		time: TimeInput!
+	): PathFromNode!
 	"""
 	Create a view of the PathFromNode including all events after the specified start (exclusive).
 	"""
-	after(time: TimeInput!): PathFromNode!
+	after(
+		"""
+		Exclusive lower bound.
+		"""
+		time: TimeInput!
+	): PathFromNode!
 	"""
 	Shrink both the start and end of the window.
 	"""
-	shrinkWindow(start: TimeInput!, end: TimeInput!): PathFromNode!
+	shrinkWindow(
+		"""
+		Proposed new start (TimeInput); ignored if it would widen the window.
+		"""
+		start: TimeInput!,
+		"""
+		Proposed new end (TimeInput); ignored if it would widen the window.
+		"""
+		end: TimeInput!
+	): PathFromNode!
 	"""
 	Set the start of the window to the larger of the specified start and self.start().
 	"""
-	shrinkStart(start: TimeInput!): PathFromNode!
+	shrinkStart(
+		"""
+		Proposed new start (TimeInput); ignored if it would widen the window.
+		"""
+		start: TimeInput!
+	): PathFromNode!
 	"""
 	Set the end of the window to the smaller of the specified end and self.end().
 	"""
-	shrinkEnd(end: TimeInput!): PathFromNode!
+	shrinkEnd(
+		"""
+		Proposed new end (TimeInput); ignored if it would widen the window.
+		"""
+		end: TimeInput!
+	): PathFromNode!
 	"""
-	Filter nodes by type.
+	Narrow this path to neighbours whose node type is in the given set.
 	"""
-	typeFilter(nodeTypes: [String!]!): PathFromNode!
+	typeFilter(
+		"""
+		Node types to keep.
+		"""
+		nodeTypes: [String!]!
+	): PathFromNode!
 	"""
 	Returns the earliest time that this PathFromNode is valid or None if the PathFromNode is valid for all times.
 	"""
@@ -2829,6 +4500,9 @@ type PathFromNode {
 	Returns the latest time that this PathFromNode is valid or None if the PathFromNode is valid for all times.
 	"""
 	end: EventTime!
+	"""
+	Number of neighbour nodes reachable from the source in this view.
+	"""
 	count: Int!
 	"""
 	Fetch one page with a number of items up to a specified limit, optionally offset by a specified amount.
@@ -2837,24 +4511,84 @@ type PathFromNode {
 	For example, if page(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
 	will be returned.
 	"""
-	page(limit: Int!, offset: Int, pageIndex: Int): [Node!]!
+	page(
+		"""
+		Maximum number of items to return on this page.
+		"""
+		limit: Int!,
+		"""
+		Extra items to skip on top of `pageIndex` paging (default 0).
+		"""
+		offset: Int,
+		"""
+		Zero-based page number; multiplies `limit` to determine where to start (default 0).
+		"""
+		pageIndex: Int
+	): [Node!]!
+	"""
+	Materialise every neighbour node in the path. Rejected by the server when
+	bulk list endpoints are disabled; use `page` for paginated access instead.
+	"""
 	list: [Node!]!
 	"""
-	Returns the node ids.
+	Every neighbour node's id (name) as a flat list of strings. Rejected by the
+	server when bulk list endpoints are disabled.
 	"""
 	ids: [String!]!
 	"""
 	Takes a specified selection of views and applies them in given order.
 	"""
-	applyViews(views: [PathFromNodeViewCollection!]!): PathFromNode!
+	applyViews(
+		"""
+		Ordered list of view operations; each entry is a one-of variant (`window`, `layer`, `filter`, ...) applied to the running result.
+		"""
+		views: [PathFromNodeViewCollection!]!
+	): PathFromNode!
 	"""
-	Returns a filtered view that applies to list down the chain
-	"""
-	filter(expr: NodeFilter!): PathFromNode!
+	Narrow the neighbour set to nodes matching `expr`. The filter sticks to
+	the returned path — every subsequent traversal (further hops, edges,
+	properties) continues to see the filtered scope.
+	
+	Useful when you want one scoping rule to apply across the whole query.
+	E.g. restricting the whole traversal to a specific week:
+	
+	```text
+	node(name: "A") { neighbours { filter(expr: {window: {...week...}}) {
+	list { neighbours { list { name } } }   # further hops still windowed
+	} } }
+	```
+	
+	Contrast with `select`, which applies here and is not carried through.
 	"""
-	Returns filtered list of neighbour nodes
+	filter(
+		"""
+		Composite node filter (by name, property, type, etc.).
+		"""
+		expr: NodeFilter!
+	): PathFromNode!
 	"""
-	select(expr: NodeFilter!): PathFromNode!
+	Narrow the neighbour set to nodes matching `expr`, but only at this hop
+	— further traversals out of these nodes see the unfiltered graph again.
+	
+	Useful when each hop needs a different scope. E.g. neighbours active on
+	Monday, then *their* neighbours active on Tuesday:
+	
+	```text
+	node(name: "A") { neighbours { select(expr: {window: {...monday...}}) {
+	list { neighbours { select(expr: {window: {...tuesday...}}) {
+	list { name }
+	} } }
+	} } }
+	```
+	
+	Contrast with `filter`, which persists the scope through subsequent ops.
+	"""
+	select(
+		"""
+		Composite node filter (by name, property, type, etc.).
+		"""
+		expr: NodeFilter!
+	): PathFromNode!
 }
 
 input PathFromNodeViewCollection @oneOf {
@@ -2912,7 +4646,16 @@ input PathFromNodeViewCollection @oneOf {
 	shrinkEnd: TimeInput
 }
 
+"""
+A lazy sequence of per-window neighbour sets, produced by
+`neighbours.rolling` / `neighbours.expanding` (or the in/out variants).
+Each entry is a `PathFromNode` scoped to that window.
+"""
 type PathFromNodeWindowSet {
+	"""
+	Number of windows in this set. Materialising all windows is expensive for
+	large graphs — prefer `page` over `list` when iterating.
+	"""
 	count: Int!
 	"""
 	Fetch one page with a number of items up to a specified limit, optionally offset by a specified amount.
@@ -2921,7 +4664,24 @@ type PathFromNodeWindowSet {
 	For example, if page(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
 	will be returned.
 	"""
-	page(limit: Int!, offset: Int, pageIndex: Int): [PathFromNode!]!
+	page(
+		"""
+		Maximum number of items to return on this page.
+		"""
+		limit: Int!,
+		"""
+		Extra items to skip on top of `pageIndex` paging (default 0).
+		"""
+		offset: Int,
+		"""
+		Zero-based page number; multiplies `limit` to determine where to start (default 0).
+		"""
+		pageIndex: Int
+	): [PathFromNode!]!
+	"""
+	Materialise every window as a list. Rejected by the server when bulk list
+	endpoints are disabled; use `page` for paginated access instead.
+	"""
 	list: [PathFromNode!]!
 }
 
@@ -3055,29 +4815,72 @@ input PropCondition @oneOf {
 	len: PropCondition
 }
 
+"""
+All temporal properties of an entity (metadata is exposed separately).
+Look up individual properties via `get` / `contains`, enumerate via
+`keys` / `values`, or drop into `temporal` for time-aware accessors.
+"""
 type Properties {
 	"""
-	Get property value matching the specified key.
+	Look up a single property by key. Returns null if no property with that key
+	exists in the current view.
 	"""
-	get(key: String!): Property
+	get(
+		"""
+		The property name.
+		"""
+		key: String!
+	): Property
 	"""
-	Check if the key is in the properties.
+	Returns true if a property with the given key exists in this view.
 	"""
-	contains(key: String!): Boolean!
+	contains(
+		"""
+		The property name to look up.
+		"""
+		key: String!
+	): Boolean!
 	"""
-	Return all property keys.
+	All property keys present in the current view. Does not include metadata
+	— metadata is exposed separately via the entity's `metadata` field.
 	"""
 	keys: [String!]!
 	"""
-	Return all property values.
+	Snapshot of property values, one `{key, value}` entry per property.
+	"""
+	values(
+		"""
+		Optional whitelist. If provided, only properties with these keys are returned; if omitted or null, every property in the view is returned.
+		"""
+		keys: [String!]
+	): [Property!]!
+	"""
+	The temporal-only view of these properties — excludes metadata (which has no
+	history) and lets you drill into per-key timelines and aggregates.
 	"""
-	values(keys: [String!]): [Property!]!
 	temporal: TemporalProperties!
 }
 
+"""
+A single `(key, value)` property reading at a point in the graph view.
+The value is exposed both as a typed scalar (`value`) and as a
+human-readable string (`asString`).
+"""
 type Property {
+	"""
+	The property key (name).
+	"""
 	key: String!
+	"""
+	The property value rendered as a human-readable string (e.g. `"10"`, `"hello"`,
+	`"2024-01-01T00:00:00Z"`). For programmatic access use `value`, which returns
+	a typed scalar.
+	"""
 	asString: String!
+	"""
+	The property value as a typed `PropertyOutput` scalar — numbers come back as
+	numbers, booleans as booleans, strings as strings, etc.
+	"""
 	value: PropertyOutput!
 }
 
@@ -3128,9 +4931,25 @@ type PropertySchema {
 	variants: [String!]!
 }
 
+"""
+A `(time, value)` pair — the output type of temporal-property accessors
+that need to report *when* a value was observed (e.g. `min`, `max`,
+`median`, `orderedDedupe`).
+"""
 type PropertyTuple {
+	"""
+	The timestamp at which this value was recorded.
+	"""
 	time: EventTime!
+	"""
+	The value rendered as a human-readable string. For programmatic access use
+	`value`, which returns a typed scalar.
+	"""
 	asString: String!
+	"""
+	The value as a typed `PropertyOutput` scalar — numbers come back as numbers,
+	booleans as booleans, etc.
+	"""
 	value: PropertyOutput!
 }
 
@@ -3149,61 +4968,140 @@ type QueryPlugin {
 	NoOps: String!
 }
 
+"""
+Top-level READ-only query root. Entry points for loading a graph
+(`graph`, `graphMetadata`), browsing stored graphs (`namespaces`,
+`namespace`, `root`), downloading a stored graph as a base64 blob
+(`receiveGraph`), inspecting vectorised variants (`vectorisedGraph`),
+and a few utility endpoints (`version`, `hello`, `plugins`).
+"""
 type QueryRoot {
 	"""
-	Hello world demo
+	Liveness check — returns a static "hello world" string. Useful for
+	smoke-testing that the GraphQL server is reachable.
 	"""
 	hello: String!
 	"""
-	Returns a graph
-	"""
-	graph(path: String!): Graph!
-	"""
-	Update graph query, has side effects to update graph state
-	
-	Returns:: GqlMutableGraph
-	"""
-	updateGraph(path: String!): MutableGraph!
-	"""
-	Update graph query, has side effects to update graph state
-	
-	Returns:: GqlMutableGraph
-	"""
-	vectoriseGraph(path: String!, model: EmbeddingModel, nodes: Template, edges: Template): Boolean!
-	"""
-	Create vectorised graph in the format used for queries
-	
-	Returns:: GqlVectorisedGraph
-	"""
-	vectorisedGraph(path: String!): VectorisedGraph
-	"""
-	Returns all namespaces using recursive search
-	
-	Returns::  List of namespaces on root
+	Load a graph by path. Returns null if the graph doesn't exist or is
+	inaccessible. When a READ-scoped filter is attached to the caller's
+	permissions, that filter is applied before the graph is returned.
+	`graphType` lets you re-interpret the stored graph at query time —
+	e.g. read an event-stored graph through persistent semantics. Defaults
+	to the type the graph was created with.
+	Requires READ on the graph.
+	"""
+	graph(
+		"""
+		Graph path relative to the root namespace (e.g. `"master"` or `"team/project/graph"`).
+		"""
+		path: String!,
+		"""
+		Optional override for graph semantics — `EVENT` treats every update as a point-in-time event, `PERSISTENT` carries values forward until overwritten or deleted. Defaults to the stored graph's native type.
+		"""
+		graphType: GraphType
+	): Graph
+	"""
+	Returns lightweight metadata for a graph (node/edge counts,
+	timestamps) without deserialising the full graph. Returns null if the
+	graph doesn't exist or is inaccessible.
+	Requires READ on the graph, or INTROSPECT on its parent namespace.
+	"""
+	graphMetadata(
+		"""
+		Graph path relative to the root namespace.
+		"""
+		path: String!
+	): MetaGraph
+	"""
+	Open a graph for writing — returns a `MutableGraph` handle that can
+	add nodes/edges/properties/metadata.
+	Requires WRITE on the graph.
+	"""
+	updateGraph(
+		"""
+		Graph path relative to the root namespace.
+		"""
+		path: String!
+	): MutableGraph!
+	"""
+	Compute and persist embeddings for the nodes and edges of a stored
+	graph so it can be queried via `vectorisedGraph`.
+	Requires WRITE access.
+	"""
+	vectoriseGraph(
+		"""
+		Graph path relative to the root namespace.
+		"""
+		path: String!,
+		"""
+		Optional embedding model; defaults to OpenAI's standard model.
+		"""
+		model: EmbeddingModel,
+		"""
+		Optional node-document template (which fields go into each node's text representation); defaults to the built-in template.
+		"""
+		nodes: Template,
+		"""
+		Optional edge-document template; defaults to the built-in template.
+		"""
+		edges: Template
+	): Boolean!
+	"""
+	Open a previously-vectorised graph for similarity queries. Returns null
+	if the graph has no embeddings (call `vectoriseGraph` first) or is
+	inaccessible.
+	Requires READ on the graph.
+	"""
+	vectorisedGraph(
+		"""
+		Graph path relative to the root namespace.
+		"""
+		path: String!
+	): VectorisedGraph
+	"""
+	Recursively list every namespace under the root. Each namespace is
+	filtered against the caller's permissions: only namespaces with at
+	least DISCOVER are returned.
 	"""
 	namespaces: CollectionOfNamespace!
 	"""
-	Returns a specific namespace at a given path
-	
-	Returns:: Namespace or error if no namespace found
+	Return a specific namespace by path. Errors if no namespace exists at
+	that path.
+	Requires INTROSPECT on the namespace to browse its contents.
 	"""
-	namespace(path: String!): Namespace!
+	namespace(
+		"""
+		Namespace path relative to the root namespace (e.g. `"team/project"`).
+		"""
+		path: String!
+	): Namespace!
 	"""
-	Returns root namespace
-	
-	Returns::  Root namespace
+	Returns the root namespace. Use it as the entry point for browsing
+	namespaces and graphs — child listings filter against the caller's
+	permissions.
 	"""
 	root: Namespace!
 	"""
-	Returns a plugin.
+	Entry point for READ-only plugins registered with the server (e.g. graph
+	algorithms exposed as queries). Available plugins are defined at server
+	startup via the plugin registry.
 	"""
 	plugins: QueryPlugin!
 	"""
-	Encodes graph and returns as string
-	
-	Returns:: Base64 url safe encoded string
+	Encode a stored graph as a base64 string for client-side download. If
+	a READ-scoped filter is attached to the caller's permissions, only the
+	materialised filtered view is encoded.
+	Requires READ on the graph.
+	"""
+	receiveGraph(
+		"""
+		Graph path relative to the root namespace.
+		"""
+		path: String!
+	): String!
+	"""
+	Version string of the running `raphtory-graphql` server build.
 	"""
-	receiveGraph(path: String!): String!
 	version: String!
 }
 
@@ -3248,46 +5146,138 @@ input Template @oneOf {
 	custom: String
 }
 
+"""
+The temporal-only view of an entity's properties. Each entry is a
+`TemporalProperty` carrying the full timeline for that key — use this when
+you need per-update iteration, time-indexed lookups, or aggregates.
+"""
 type TemporalProperties {
 	"""
-	Get property value matching the specified key.
+	Look up a single temporal property by key. Returns null if there's no temporal
+	property with that key.
 	"""
-	get(key: String!): TemporalProperty
+	get(
+		"""
+		The property name.
+		"""
+		key: String!
+	): TemporalProperty
 	"""
-	Check if the key is in the properties.
+	Returns true if a temporal property with the given key exists.
 	"""
-	contains(key: String!): Boolean!
+	contains(
+		"""
+		The property name to look up.
+		"""
+		key: String!
+	): Boolean!
 	"""
-	Return all property keys.
+	All temporal-property keys present in this view.
 	"""
 	keys: [String!]!
 	"""
-	Return all property values.
+	All temporal properties, each as a `TemporalProperty` with its full timeline
+	available. Use `history`, `values`, `latest`, `at`, etc. on each entry.
 	"""
-	values(keys: [String!]): [TemporalProperty!]!
+	values(
+		"""
+		Optional whitelist. If provided, only temporal properties with these keys are returned; if omitted, every temporal property in the view is returned.
+		"""
+		keys: [String!]
+	): [TemporalProperty!]!
 }
 
+"""
+The full timeline of a single property key on one entity. Exposes every
+update (via `values` / `history` / `orderedDedupe`), point lookups (`at`,
+`latest`), and aggregates over the timeline (`sum`, `mean`, `min`, `max`,
+`median`, `count`).
+"""
 type TemporalProperty {
 	"""
-	Key of a property.
+	The property key (name).
 	"""
 	key: String!
+	"""
+	Event history for this property — one entry per temporal update, in
+	insertion order. Use this to navigate the full timeline: access the
+	raw `timestamps` / `datetimes` / `eventId` lists, analyse gaps between
+	updates via `intervals` (mean/median/min/max), ask `isEmpty`, or
+	paginate the events.
+	"""
 	history: History!
 	"""
-	Return the values of the properties.
+	All values this property has ever taken, in temporal order (one per update).
+	Typed as `PropertyOutput` so numeric values stay numeric.
+	"""
+	values: [PropertyOutput!]!
+	"""
+	The value at or before time `t` (latest update on or before `t`). Returns null
+	if no update exists on or before `t`.
+	"""
+	at(
+		"""
+		A TimeInput (epoch millis integer, RFC3339 string, or `{timestamp, eventId}` object).
+		"""
+		t: TimeInput!
+	): PropertyOutput
+	"""
+	The most recent value, or null if the property has never been set in this view.
+	"""
+	latest: PropertyOutput
+	"""
+	The set of distinct values this property has ever taken (order not guaranteed).
+	"""
+	unique: [PropertyOutput!]!
+	"""
+	Collapses runs of consecutive-equal updates into a single `(time, value)` pair.
+	"""
+	orderedDedupe(
+		"""
+		If true, each run is represented by its *last* timestamp; if false, by its *first*. Useful for compressing chatter in a timeline.
+		"""
+		latestTime: Boolean!
+	): [PropertyTuple!]!
+	"""
+	Sum of all updates. Returns null if the dtype is not additive or the property is empty.
+	"""
+	sum: PropertyOutput
+	"""
+	Mean of all updates as an F64. Returns null if any value is non-numeric or the property is
+	empty.
+	"""
+	mean: PropertyOutput
+	"""
+	Alias for `mean` — same F64 average, same null cases.
+	"""
+	average: PropertyOutput
+	"""
+	Minimum `(time, value)` pair. Returns null if the dtype is not comparable or the property is
+	empty.
+	"""
+	min: PropertyTuple
+	"""
+	Maximum `(time, value)` pair. Returns null if the dtype is not comparable or the property is
+	empty.
 	"""
-	values: [String!]!
-	at(t: TimeInput!): String
-	latest: String
-	unique: [String!]!
-	orderedDedupe(latestTime: Boolean!): [PropertyTuple!]!
+	max: PropertyTuple
+	"""
+	Median `(time, value)` pair (lower median on even-length inputs). Returns null if the dtype
+	is not comparable or the property is empty.
+	"""
+	median: PropertyTuple
+	"""
+	Number of updates recorded for this property in the current view.
+	"""
+	count: Int!
 }
 
 input TemporalPropertyInput {
 	"""
-	Time.
+	Time of the update — accepts the same forms as `TimeInput` (epoch
+	millis Int, RFC3339 string, or `{timestamp, eventId}` object).
 	"""
-	time: Int!
+	time: TimeInput!
 	"""
 	Properties.
 	"""
@@ -3299,6 +5289,11 @@ Input for primary time component. Expects Int, DateTime formatted String, or Obj
 where the timestamp is either an Int or a DateTime formatted String, and eventId is a non-negative Int.
 Valid string formats are RFC3339, RFC2822, %Y-%m-%d, %Y-%m-%dT%H:%M:%S%.3f, %Y-%m-%dT%H:%M:%S%,
 %Y-%m-%d %H:%M:%S%.3f and %Y-%m-%d %H:%M:%S%.
+
+Internally wraps `InputTime` so write paths (`addNode`, `addEdge`,
+`addProperties`, etc.) can preserve auto-increment of `event_id` when only
+a timestamp is given. Pass the object form `{timestamp, eventId}` to lock
+the event_id explicitly.
 """
 scalar TimeInput
 
@@ -3356,8 +5351,26 @@ input Value @oneOf {
 	Object.
 	"""
 	object: [ObjectEntry!]
+	"""
+	Timezone-aware datetime.
+	"""
+	dtime: String
+	"""
+	Naive datetime (no timezone).
+	"""
+	ndtime: String
+	"""
+	BigDecimal number (string representation, e.g. "3.14159" or "123e-5").
+	"""
+	decimal: String
 }
 
+"""
+A working set of documents / nodes / edges built up via similarity
+searches on a `VectorisedGraph`. Selections are mutable: you can grow
+them with more hops (`expand*`), dereference the contents (`nodes`,
+`edges`, `getDocuments`), or start fresh with `emptySelection`.
+"""
 type VectorSelection {
 	"""
 	Returns a list of nodes in the current selection.
@@ -3372,40 +5385,109 @@ type VectorSelection {
 	"""
 	getDocuments: [Document!]!
 	"""
-	Adds all the documents associated with the specified nodes to the current selection.
-	
-	Documents added by this call are assumed to have a score of 0.
-	"""
-	addNodes(nodes: [String!]!): VectorSelection!
-	"""
-	Adds all the documents associated with the specified edges to the current selection.
-	
-	Documents added by this call are assumed to have a score of 0.
-	"""
-	addEdges(edges: [InputEdge!]!): VectorSelection!
-	"""
-	Add all the documents a specified number of hops away to the selection.
-	
-	Two documents A and B are considered to be 1 hop away of each other if they are on the same entity or if they are on the same node and edge pair.
-	"""
-	expand(hops: Int!, window: VectorisedGraphWindow): VectorSelection!
-	"""
-	Adds documents, from the set of one hop neighbours to the current selection, to the selection based on their similarity score with the specified query. This function loops so that the set of one hop neighbours expands on each loop and number of documents added is determined by the specified limit.
-	"""
-	expandEntitiesBySimilarity(query: String!, limit: Int!, window: VectorisedGraphWindow): VectorSelection!
-	"""
-	Add the adjacent nodes with higher score for query to the selection up to a specified limit. This function loops like expand_entities_by_similarity but is restricted to nodes.
-	"""
-	expandNodesBySimilarity(query: String!, limit: Int!, window: VectorisedGraphWindow): VectorSelection!
-	"""
-	Add the adjacent edges with higher score for query to the selection up to a specified limit. This function loops like expand_entities_by_similarity but is restricted to edges.
-	"""
-	expandEdgesBySimilarity(query: String!, limit: Int!, window: VectorisedGraphWindow): VectorSelection!
+	Add every document associated with the named nodes to the selection.
+	Documents added this way receive a score of 0 (no similarity ranking).
+	"""
+	addNodes(
+		"""
+		Node ids whose documents to include.
+		"""
+		nodes: [NodeId!]!
+	): VectorSelection!
+	"""
+	Add every document associated with the named edges to the selection.
+	Documents added this way receive a score of 0 (no similarity ranking).
+	"""
+	addEdges(
+		"""
+		List of `{src, dst}` pairs identifying the edges.
+		"""
+		edges: [InputEdge!]!
+	): VectorSelection!
+	"""
+	Grow the selection by including documents that are within `hops` of any
+	document already in the selection. Two documents are 1 hop apart if
+	they're on the same entity or on a connected node/edge pair.
+	"""
+	expand(
+		"""
+		Number of expansion rounds (1 = direct neighbours).
+		"""
+		hops: Int!,
+		"""
+		Optional `{start, end}` to restrict expansion to entities active in that interval.
+		"""
+		window: VectorisedGraphWindow
+	): VectorSelection!
+	"""
+	Iteratively expand the selection by similarity to a natural-language
+	query. Each pass takes the one-hop neighbour set of the current
+	selection and adds the highest-scoring entities (mixed nodes and
+	edges); the loop continues until `limit` entities have been added.
+	"""
+	expandEntitiesBySimilarity(
+		"""
+		Natural-language search string; embedded by the server.
+		"""
+		query: String!,
+		"""
+		Total number of entities to add across all passes.
+		"""
+		limit: Int!,
+		"""
+		Optional `{start, end}` to restrict matches to entities active in that interval.
+		"""
+		window: VectorisedGraphWindow
+	): VectorSelection!
+	"""
+	Like `expandEntitiesBySimilarity` but restricted to nodes — iteratively
+	add the highest-scoring adjacent nodes to the selection.
+	"""
+	expandNodesBySimilarity(
+		"""
+		Natural-language search string; embedded by the server.
+		"""
+		query: String!,
+		"""
+		Total number of nodes to add across all passes.
+		"""
+		limit: Int!,
+		"""
+		Optional `{start, end}` to restrict matches to nodes active in that interval.
+		"""
+		window: VectorisedGraphWindow
+	): VectorSelection!
+	"""
+	Like `expandEntitiesBySimilarity` but restricted to edges — iteratively
+	add the highest-scoring adjacent edges to the selection.
+	"""
+	expandEdgesBySimilarity(
+		"""
+		Natural-language search string; embedded by the server.
+		"""
+		query: String!,
+		"""
+		Total number of edges to add across all passes.
+		"""
+		limit: Int!,
+		"""
+		Optional `{start, end}` to restrict matches to edges active in that interval.
+		"""
+		window: VectorisedGraphWindow
+	): VectorSelection!
 }
 
+"""
+A graph with embedded vector representations for its nodes and edges.
+Exposes similarity search over documents, nodes, and edges, plus
+selection building (`emptySelection`) and index maintenance
+(`optimizeIndex`).
+"""
 type VectorisedGraph {
 	"""
-	Optmize the vector index
+	Rebuild (or incrementally update) the on-disk vector indexes for nodes
+	and edges so subsequent similarity searches hit the fresh embeddings.
+	Safe to call repeatedly; returns true on success.
 	"""
 	optimizeIndex: Boolean!
 	"""
@@ -3413,28 +5495,73 @@ type VectorisedGraph {
 	"""
 	emptySelection: VectorSelection!
 	"""
-	Search the top scoring entities according to a specified query returning no more than a specified limit of entities.
-	"""
-	entitiesBySimilarity(query: String!, limit: Int!, window: VectorisedGraphWindow): VectorSelection!
-	"""
-	Search the top scoring nodes according to a specified query returning no more than a specified limit of nodes.
-	"""
-	nodesBySimilarity(query: String!, limit: Int!, window: VectorisedGraphWindow): VectorSelection!
-	"""
-	Search the top scoring edges according to a specified query returning no more than a specified limit of edges.
-	"""
-	edgesBySimilarity(query: String!, limit: Int!, window: VectorisedGraphWindow): VectorSelection!
+	Find the highest-scoring nodes *and* edges (mixed) by similarity to a
+	natural-language query. The query is embedded server-side and matched
+	against indexed entity vectors.
+	"""
+	entitiesBySimilarity(
+		"""
+		Natural-language search string; embedded by the server.
+		"""
+		query: String!,
+		"""
+		Maximum number of results to return.
+		"""
+		limit: Int!,
+		"""
+		Optional `{start, end}` to restrict matches to entities active in that interval.
+		"""
+		window: VectorisedGraphWindow
+	): VectorSelection!
+	"""
+	Find the highest-scoring nodes by similarity to a natural-language
+	query. The query is embedded server-side and matched against indexed
+	node vectors.
+	"""
+	nodesBySimilarity(
+		"""
+		Natural-language search string; embedded by the server.
+		"""
+		query: String!,
+		"""
+		Maximum number of nodes to return.
+		"""
+		limit: Int!,
+		"""
+		Optional `{start, end}` to restrict matches to nodes active in that interval.
+		"""
+		window: VectorisedGraphWindow
+	): VectorSelection!
+	"""
+	Find the highest-scoring edges by similarity to a natural-language
+	query. The query is embedded server-side and matched against indexed
+	edge vectors.
+	"""
+	edgesBySimilarity(
+		"""
+		Natural-language search string; embedded by the server.
+		"""
+		query: String!,
+		"""
+		Maximum number of edges to return.
+		"""
+		limit: Int!,
+		"""
+		Optional `{start, end}` to restrict matches to edges active in that interval.
+		"""
+		window: VectorisedGraphWindow
+	): VectorSelection!
 }
 
 input VectorisedGraphWindow {
 	"""
-	Start time.
+	Inclusive lower bound of the search window.
 	"""
-	start: Int!
+	start: TimeInput!
 	"""
-	End time.
+	Exclusive upper bound of the search window.
 	"""
-	end: Int!
+	end: TimeInput!
 }
 
 input Window {
diff --git a/raphtory-graphql/src/auth.rs b/raphtory-graphql/src/auth.rs
index 1626bf38a3..bae5a83bd2 100644
--- a/raphtory-graphql/src/auth.rs
+++ b/raphtory-graphql/src/auth.rs
@@ -1,4 +1,4 @@
-use crate::config::auth_config::{AuthConfig, PublicKey};
+use crate::config::{app_config::AppConfig, auth_config::PublicKey};
 use async_graphql::{
     async_trait,
     extensions::{Extension, ExtensionContext, ExtensionFactory, NextParseQuery},
@@ -10,59 +10,55 @@ use async_graphql_poem::{GraphQLBatchRequest, GraphQLBatchResponse, GraphQLReque
 use futures_util::StreamExt;
 use jsonwebtoken::{decode, Algorithm, Validation};
 use poem::{
-    error::{TooManyRequests, Unauthorized},
+    error::{BadRequest, TooManyRequests, Unauthorized},
     Body, Endpoint, FromRequest, IntoResponse, Request, Response, Result,
 };
 use reqwest::header::AUTHORIZATION;
 use serde::Deserialize;
 use std::{sync::Arc, time::Duration};
 use tokio::sync::{RwLock, Semaphore};
+use tracing::{debug, warn};
 
 #[derive(Clone, Debug, Deserialize, PartialEq)]
 #[serde(rename_all = "lowercase")]
-pub(crate) enum Access {
+pub enum Access {
     Ro,
     Rw,
 }
 
 #[derive(Deserialize, Debug, Clone)]
 pub(crate) struct TokenClaims {
-    pub(crate) a: Access,
+    pub(crate) access: Access,
+    #[serde(default)]
+    pub(crate) role: Option<String>,
 }
 
 // TODO: maybe this should be renamed as it doens't only take care of auth anymore
 pub struct AuthenticatedGraphQL<E> {
     executor: E,
-    config: AuthConfig,
+    config: AppConfig,
     semaphore: Option<Semaphore>,
-    lock: Option<RwLock<()>>,
+    lock: Option<tokio::sync::RwLock<()>>,
 }
 
 impl<E> AuthenticatedGraphQL<E> {
     /// Create a GraphQL endpoint.
-    pub fn new(executor: E, config: AuthConfig) -> Self {
+    pub fn new(executor: E, config: AppConfig) -> Self {
+        let semaphore = config.concurrency.heavy_query_limit.map(|limit| {
+            println!("Server running with concurrency limited to {limit} for heavy queries");
+            Semaphore::new(limit)
+        });
+        let lock = if config.concurrency.exclusive_writes {
+            println!("Server running with exclusive writes");
+            Some(RwLock::new(()))
+        } else {
+            None
+        };
         Self {
             executor,
             config,
-            semaphore: std::env::var("RAPHTORY_CONCURRENCY_LIMIT")
-                .ok()
-                .and_then(|limit| {
-                    let limit = limit.parse::<usize>().ok()?;
-                    println!(
-                        "Server running with concurrency limited to {limit} for heavy queries"
-                    );
-                    Some(Semaphore::new(limit))
-                }),
-            lock: std::env::var("RAPHTORY_THREADSAFE")
-                .ok()
-                .and_then(|thread_safe| {
-                    if thread_safe == "1" {
-                        println!("Server running in threadsafe mode");
-                        Some(RwLock::new(()))
-                    } else {
-                        None
-                    }
-                }),
+            semaphore,
+            lock,
         }
     }
 }
@@ -103,6 +99,10 @@ pub enum AuthError {
     RequireRead,
     #[error("The requested endpoint requires write access")]
     RequireWrite,
+    #[error("Query batching is disabled on this server")]
+    BatchingDisabled,
+    #[error("Batch size {actual} exceeds the maximum allowed {max}")]
+    BatchSizeExceeded { max: usize, actual: usize },
 }
 
 impl From<AuthError> for ServerError {
@@ -124,23 +124,28 @@ where
 
     async fn call(&self, req: Request) -> Result<Self::Output> {
         // here ANY error when trying to validate the Authorization header is equivalent to it not being present at all
-        let access = match &self.config.public_key {
+        let (access, role) = match &self.config.auth.public_key {
             Some(public_key) => {
-                let presented_access = req
+                let claims = req
                     .header(AUTHORIZATION)
-                    .and_then(|header| extract_access_from_header(header, public_key));
-                match presented_access {
-                    Some(access) => access,
+                    .and_then(|header| extract_claims_from_header(header, public_key));
+                match claims {
+                    Some(claims) => {
+                        debug!(role = ?claims.role, "JWT validated successfully");
+                        (claims.access, claims.role)
+                    }
                     None => {
-                        if self.config.enabled_for_reads {
+                        if self.config.auth.require_auth_for_reads {
+                            warn!("Request missing valid JWT — rejecting (require_auth_for_reads=true)");
                             return Err(Unauthorized(AuthError::RequireRead));
                         } else {
-                            Access::Ro // if read access is not required, we give read access to all requests
+                            debug!("No valid JWT but require_auth_for_reads=false — granting read access");
+                            (Access::Ro, None)
                         }
                     }
                 }
             }
-            None => Access::Rw, // if auth is not setup, we give write access to all requests
+            None => (Access::Rw, None), // if auth is not setup, we give write access to all requests
         };
 
         let is_accept_multipart_mixed = req
@@ -151,7 +156,7 @@ where
         if is_accept_multipart_mixed {
             let (req, mut body) = req.split();
             let req = GraphQLRequest::from_request(&req, &mut body).await?;
-            let req = req.0.data(access);
+            let req = req.0.data(access).data(role);
             let stream = self.executor.execute_stream(req, None);
             Ok(Response::builder()
                 .header("content-type", "multipart/mixed; boundary=graphql")
@@ -161,8 +166,21 @@ where
                 )))
         } else {
             let (req, mut body) = req.split();
-            let req = GraphQLBatchRequest::from_request(&req, &mut body).await?;
-            let req = req.0.data(access);
+            let batch_req = GraphQLBatchRequest::from_request(&req, &mut body).await?.0;
+
+            if let BatchRequest::Batch(requests) = &batch_req {
+                if self.config.concurrency.disable_batching {
+                    return Err(BadRequest(AuthError::BatchingDisabled));
+                }
+                if let Some(max) = self.config.concurrency.max_batch_size {
+                    let actual = requests.len();
+                    if actual > max {
+                        return Err(BadRequest(AuthError::BatchSizeExceeded { max, actual }));
+                    }
+                }
+            }
+
+            let req = batch_req.data(access).data(role);
 
             let contains_update = match &req {
                 BatchRequest::Single(request) => request.query.contains("updateGraph"),
@@ -200,28 +218,50 @@ fn is_query_heavy(query: &str) -> bool {
         || query.contains("inNeighbours")
 }
 
-fn extract_access_from_header(header: &str, public_key: &PublicKey) -> Option<Access> {
+fn extract_claims_from_header(header: &str, public_key: &PublicKey) -> Option<TokenClaims> {
     if header.starts_with("Bearer ") {
         let jwt = header.replace("Bearer ", "");
-        let mut validation = Validation::new(Algorithm::EdDSA);
+        let mut validation = Validation::new(public_key.algorithms[0]);
+        validation.algorithms = public_key.algorithms.clone();
         validation.set_required_spec_claims::<String>(&[]); // we don't require 'exp' to be present
         let decoded = decode::<TokenClaims>(&jwt, &public_key.decoding_key, &validation);
-        Some(decoded.ok()?.claims.a)
+        match decoded {
+            Ok(token_data) => Some(token_data.claims),
+            Err(e) => {
+                warn!(error = %e, "JWT signature validation failed");
+                None
+            }
+        }
     } else {
+        warn!("Authorization header is missing or does not start with 'Bearer '");
         None
     }
 }
 
 pub(crate) trait ContextValidation {
-    fn require_write_access(&self) -> Result<(), AuthError>;
+    fn require_jwt_write_access(&self) -> Result<(), AuthError>;
+}
+
+/// Check that the request carries a write-access JWT (`"access": "rw"`).
+/// For use in dynamic resolver ops that run under `query { ... }` and are
+/// therefore not covered by the `MutationAuth` extension.
+pub fn require_jwt_write_access_dynamic(
+    ctx: &async_graphql::dynamic::ResolverContext,
+) -> Result<(), async_graphql::Error> {
+    if ctx.data::<Access>().is_ok_and(|a| a == &Access::Rw) {
+        Ok(())
+    } else {
+        Err(async_graphql::Error::new(
+            "Access denied: write access required",
+        ))
+    }
 }
 
 impl<'a> ContextValidation for &Context<'a> {
-    fn require_write_access(&self) -> Result<(), AuthError> {
-        if self.data::<Access>().is_ok_and(|role| role == &Access::Rw) {
-            Ok(())
-        } else {
-            Err(AuthError::RequireWrite)
+    fn require_jwt_write_access(&self) -> Result<(), AuthError> {
+        match self.data::<Access>() {
+            Ok(access) if access == &Access::Rw => Ok(()),
+            _ => Err(AuthError::RequireWrite),
         }
     }
 }
@@ -249,10 +289,18 @@ impl Extension for MutationAuth {
                 .iter()
                 .any(|op| op.1.node.ty == OperationType::Mutation);
             if mutation && ctx.data::<Access>() != Ok(&Access::Rw) {
-                Err(AuthError::RequireWrite.into())
-            } else {
-                Ok(doc)
+                // If a policy is active, allow "ro" users through to resolvers —
+                // each resolver enforces its own per-graph or admin-only check.
+                // Without a policy (OSS), preserve the original blanket deny.
+                let policy_active = ctx
+                    .data::<crate::data::Data>()
+                    .map(|d| d.auth_policy.is_some())
+                    .unwrap_or(false);
+                if !policy_active {
+                    return Err(AuthError::RequireWrite.into());
+                }
             }
+            Ok(doc)
         })
     }
 }
diff --git a/raphtory-graphql/src/auth_policy.rs b/raphtory-graphql/src/auth_policy.rs
new file mode 100644
index 0000000000..30696c3cc6
--- /dev/null
+++ b/raphtory-graphql/src/auth_policy.rs
@@ -0,0 +1,128 @@
+use crate::model::graph::filtering::GraphAccessFilter;
+
+/// Opaque error returned by [`AuthorizationPolicy::graph_permissions`] when access is entirely
+/// denied. The message is intended for logging only; callers must not surface it to end users.
+#[derive(Debug)]
+pub struct AuthPolicyError(String);
+
+impl AuthPolicyError {
+    pub fn new(msg: impl Into<String>) -> Self {
+        Self(msg.into())
+    }
+}
+
+impl std::fmt::Display for AuthPolicyError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&self.0)
+    }
+}
+
+// async_graphql's blanket `impl<T: Display + Send + Sync + 'static> From<T> for Error` covers
+// AuthPolicyError automatically via its Display impl.
+
+/// The effective permission level a principal has on a specific graph.
+/// Variants are ordered by the hierarchy: `Write` > `Read{filter:None}` > `Read{filter:Some}` > `Introspect`.
+/// A filtered `Read` is less powerful than an unfiltered `Read` because it sees a restricted view.
+#[derive(Clone)]
+pub enum GraphPermission {
+    /// May query graph metadata (counts, schema) but not read data.
+    Introspect,
+    /// May read graph data; optionally restricted by a data filter.
+    Read { filter: Option<GraphAccessFilter> },
+    /// May read and mutate the graph (implies `Read` and `Introspect`, never filtered).
+    Write,
+}
+
+impl GraphPermission {
+    /// Numeric level used for ordering: `Introspect`=0, `Read{Some}`=1, `Read{None}`=2, `Write`=3.
+    fn level(&self) -> u8 {
+        match self {
+            GraphPermission::Introspect => 0,
+            GraphPermission::Read { filter: Some(_) } => 1,
+            GraphPermission::Read { filter: None } => 2,
+            GraphPermission::Write => 3,
+        }
+    }
+
+    /// Returns `true` if the permission level is `Read` or higher.
+    pub fn is_at_least_read(&self) -> bool {
+        self.level() >= 1
+    }
+
+    /// Returns `true` only for `Write` permission.
+    pub fn is_write(&self) -> bool {
+        self.level() >= 3
+    }
+
+    /// Returns `Some(self)` if at least `Read` (filtered or not), `None` otherwise.
+    /// Use with `?` to gate access and preserve the permission value for filter extraction.
+    pub fn at_least_read(self) -> Option<Self> {
+        self.is_at_least_read().then_some(self)
+    }
+
+    /// Returns `Some(self)` if `Write`, `None` otherwise.
+    pub fn at_least_write(self) -> Option<Self> {
+        self.is_write().then_some(self)
+    }
+}
+
+impl PartialEq for GraphPermission {
+    fn eq(&self, other: &Self) -> bool {
+        self.level() == other.level()
+    }
+}
+
+impl Eq for GraphPermission {}
+
+impl PartialOrd for GraphPermission {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for GraphPermission {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.level().cmp(&other.level())
+    }
+}
+
+/// The effective permission level a principal has on a namespace.
+/// Variants are ordered lowest to highest so that `PartialOrd`/`Ord` reflect the hierarchy.
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub enum NamespacePermission {
+    /// No access — namespace is invisible.
+    Denied,
+    /// Namespace is visible in parent `children()` listings but cannot be browsed.
+    Discover,
+    /// Namespace is browseable; graphs inside are visible as MetaGraph in `graphs()`.
+    Introspect,
+    /// All descendant graphs are fully readable.
+    Read,
+    /// All descendants are writable; `newGraph` is allowed.
+    Write,
+}
+
+pub trait AuthorizationPolicy: Send + Sync + 'static {
+    /// Resolves the effective permission level for a principal on a graph.
+    /// Returns `Err(denial message)` only when access is entirely denied (not even introspect).
+    /// Admin principals (`"access": "rw"` JWT) always yield `Write`.
+    /// Empty store (no roles configured) yields `Read` — fail open for reads,
+    /// but write still requires an explicit `Write` grant.
+    /// The implementation is responsible for extracting principal identity from `ctx`.
+    fn graph_permissions(
+        &self,
+        ctx: &async_graphql::Context<'_>,
+        path: &str,
+    ) -> Result<GraphPermission, AuthPolicyError>;
+
+    /// Resolves the effective namespace permission for a principal.
+    /// Admin principals always yield `Write`.
+    /// Empty store yields `Read` (fail open, consistent with graph_permissions).
+    /// Missing role yields `Denied`.
+    /// The implementation is responsible for extracting principal identity from `ctx`.
+    fn namespace_permissions(
+        &self,
+        ctx: &async_graphql::Context<'_>,
+        path: &str,
+    ) -> NamespacePermission;
+}
diff --git a/raphtory-graphql/src/cli.rs b/raphtory-graphql/src/cli.rs
index a51cb906e9..56a7bbe242 100644
--- a/raphtory-graphql/src/cli.rs
+++ b/raphtory-graphql/src/cli.rs
@@ -3,19 +3,24 @@ use crate::config::index_config::DEFAULT_CREATE_INDEX;
 use crate::{
     config::{
         app_config::AppConfigBuilder,
-        auth_config::{DEFAULT_AUTH_ENABLED_FOR_READS, PUBLIC_KEY_DECODING_ERR_MSG},
+        auth_config::{DEFAULT_REQUIRE_AUTH_FOR_READS, PUBLIC_KEY_DECODING_ERR_MSG},
         cache_config::{DEFAULT_CAPACITY, DEFAULT_TTI_SECONDS},
+        concurrency_config::{
+            DEFAULT_DISABLE_BATCHING, DEFAULT_DISABLE_LISTS, DEFAULT_EXCLUSIVE_WRITES,
+        },
         log_config::DEFAULT_LOG_LEVEL,
         otlp_config::{
             TracingLevel, DEFAULT_OTLP_AGENT_HOST, DEFAULT_OTLP_AGENT_PORT,
             DEFAULT_OTLP_TRACING_SERVICE_NAME, DEFAULT_TRACING_ENABLED, DEFAULT_TRACING_LEVEL,
         },
+        schema_config::DEFAULT_DISABLE_INTROSPECTION,
     },
     model::App,
-    server::DEFAULT_PORT,
+    server::{apply_server_extension, DEFAULT_PORT},
     GraphServer,
 };
 use clap::{Parser, Subcommand};
+use raphtory::db::api::storage::storage::Config;
 use std::path::PathBuf;
 use tokio::io::Result as IoResult;
 
@@ -74,15 +79,109 @@ struct ServerArgs {
     #[arg(long, env = "RAPHTORY_AUTH_PUBLIC_KEY", default_value = None, help = "Public key for auth")]
     auth_public_key: Option<String>,
 
-    #[arg(long, env = "RAPHTORY_AUTH_ENABLED_FOR_READS", default_value_t = DEFAULT_AUTH_ENABLED_FOR_READS, help = "Enable auth for reads")]
-    auth_enabled_for_reads: bool,
+    #[arg(long, env = "RAPHTORY_REQUIRE_AUTH_FOR_READS", default_value_t = DEFAULT_REQUIRE_AUTH_FOR_READS, help = "Require JWT authentication for read requests (default: true)")]
+    require_auth_for_reads: bool,
+
+    #[arg(
+        long,
+        env = "RAPHTORY_HEAVY_QUERY_LIMIT",
+        default_value = None,
+        help = "Restricts how many expensive graph traversal queries can execute simultaneously. Covers operations like connected components, edge traversals, and neighbour lookups (outComponent, inComponent, edges, outEdges, inEdges, neighbours, outNeighbours, inNeighbours). Once the limit is exceeded, queries are parked on a semaphore and wait until a slot becomes available before executing."
+    )]
+    heavy_query_limit: Option<usize>,
+
+    #[arg(
+        long,
+        env = "RAPHTORY_EXCLUSIVE_WRITES",
+        default_value_t = DEFAULT_EXCLUSIVE_WRITES,
+        help = "Ensures only one ingestion/write operation runs at a time and blocks reads until it completes."
+    )]
+    exclusive_writes: bool,
+
+    #[arg(
+        long,
+        env = "RAPHTORY_DISABLE_BATCHING",
+        default_value_t = DEFAULT_DISABLE_BATCHING,
+        help = "Rejects batched GraphQL requests outright. Batching can otherwise be used to circumvent per-request depth and complexity limits."
+    )]
+    disable_batching: bool,
+
+    #[arg(
+        long,
+        env = "RAPHTORY_MAX_BATCH_SIZE",
+        default_value = None,
+        help = "Caps the number of queries accepted in a single batched HTTP request. Requests whose batch exceeds this size are rejected."
+    )]
+    max_batch_size: Option<usize>,
+
+    #[arg(
+        long,
+        env = "RAPHTORY_DISABLE_LISTS",
+        default_value_t = DEFAULT_DISABLE_LISTS,
+        help = "Completely disables bulk list endpoints (e.g. listing all nodes/edges). Essential for large graphs where unbounded list queries could return billions of results and exhaust server resources."
+    )]
+    disable_lists: bool,
+
+    #[arg(
+        long,
+        env = "RAPHTORY_MAX_PAGE_SIZE",
+        default_value = None,
+        help = "Maximum page size enforced on paged collection queries. Caps the `limit` argument of `page` so clients can't circumvent `disable_lists` by requesting huge pages."
+    )]
+    max_page_size: Option<usize>,
+
+    #[arg(
+        long,
+        env = "RAPHTORY_MAX_QUERY_DEPTH",
+        default_value = None,
+        help = "Limits how deeply nested a query can be."
+    )]
+    max_query_depth: Option<usize>,
+
+    #[arg(
+        long,
+        env = "RAPHTORY_MAX_QUERY_COMPLEXITY",
+        default_value = None,
+        help = "Limits the total estimated cost of a query based on the number of fields selected. Blocks queries that try to fetch too much data in one request."
+    )]
+    max_query_complexity: Option<usize>,
+
+    #[arg(
+        long,
+        env = "RAPHTORY_MAX_RECURSIVE_DEPTH",
+        default_value = None,
+        help = "Internal safety limit to prevent stack overflows from pathologically structured queries. Falls back to the async-graphql default of 32 if unset."
+    )]
+    max_recursive_depth: Option<usize>,
+
+    #[arg(
+        long,
+        env = "RAPHTORY_MAX_DIRECTIVES_PER_FIELD",
+        default_value = None,
+        help = "Limits the number of GraphQL directives on any single field. Directives are annotations prefixed with @ that modify how a field is executed (e.g. @skip, @include, @deprecated)."
+    )]
+    max_directives_per_field: Option<usize>,
+
+    #[arg(
+        long,
+        env = "RAPHTORY_DISABLE_INTROSPECTION",
+        default_value_t = DEFAULT_DISABLE_INTROSPECTION,
+        help = "Fully disable schema introspection, preventing clients from discovering the API's structure and available fields. Recommended for production."
+    )]
+    disable_introspection: bool,
 
     #[arg(long, env = "RAPHTORY_PUBLIC_DIR", default_value = None, help = "Public directory path")]
     public_dir: Option<PathBuf>,
 
+    #[arg(long, env = "RAPHTORY_PERMISSIONS_STORE_PATH", default_value = None, help = "Path to the JSON permissions store file")]
+    permissions_store_path: Option<PathBuf>,
+
     #[cfg(feature = "search")]
     #[arg(long, env = "RAPHTORY_CREATE_INDEX", default_value_t = DEFAULT_CREATE_INDEX, help = "Enable index creation")]
     create_index: bool,
+
+    #[command(flatten)]
+    graph_config: Config,
 }
 
 pub(crate) async fn cli_with_args<I, T>(args_iter: I) -> IoResult<()>
@@ -110,7 +209,18 @@ where
                 .with_auth_public_key(server_args.auth_public_key)
                 .expect(PUBLIC_KEY_DECODING_ERR_MSG)
                 .with_public_dir(server_args.public_dir)
-                .with_auth_enabled_for_reads(server_args.auth_enabled_for_reads);
+                .with_require_auth_for_reads(server_args.require_auth_for_reads)
+                .with_heavy_query_limit(server_args.heavy_query_limit)
+                .with_exclusive_writes(server_args.exclusive_writes)
+                .with_disable_batching(server_args.disable_batching)
+                .with_max_batch_size(server_args.max_batch_size)
+                .with_disable_lists(server_args.disable_lists)
+                .with_max_page_size(server_args.max_page_size)
+                .with_max_query_depth(server_args.max_query_depth)
+                .with_max_query_complexity(server_args.max_query_complexity)
+                .with_max_recursive_depth(server_args.max_recursive_depth)
+                .with_max_directives_per_field(server_args.max_directives_per_field)
+                .with_disable_introspection(server_args.disable_introspection);
 
             #[cfg(feature = "search")]
             {
@@ -119,10 +229,16 @@ where
 
             let app_config = Some(builder.build());
 
-            GraphServer::new(server_args.work_dir, app_config, None)
-                .await?
-                .run_with_port(server_args.port)
-                .await?;
+            let server = GraphServer::new(
+                server_args.work_dir,
+                app_config,
+                None,
+                server_args.graph_config,
+            )
+            .await?;
+            let server =
+                apply_server_extension(server, server_args.permissions_store_path.as_deref());
+            server.run_with_port(server_args.port).await?;
         }
     }
     Ok(())
@@ -132,6 +248,10 @@ pub async fn cli() -> IoResult<()> {
     cli_with_args(std::env::args_os()).await
 }
 
+/// Run the Raphtory GraphQL CLI from Python. Uses `sys.argv` for arguments.
+///
+/// Returns:
+///     None:
 #[cfg(feature = "python")]
 #[pyo3::pyfunction(name = "cli")]
 pub fn python_cli() -> pyo3::PyResult<()> {
diff --git a/raphtory-graphql/src/client/error.rs b/raphtory-graphql/src/client/error.rs
new file mode 100644
index 0000000000..e58f38a9c3
--- /dev/null
+++ b/raphtory-graphql/src/client/error.rs
@@ -0,0 +1,30 @@
+//! Error type for the GraphQL client.
+
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum ClientError {
+    #[error("Network/request error: {0}")]
+    Request(#[from] reqwest::Error),
+
+    #[error("{0}")]
+    HttpError(String),
+
+    #[error("GraphQL errors: {0}")]
+    GraphQLErrors(String),
+
+    #[error("Invalid response: {0}")]
+    InvalidResponse(String),
+
+    #[error("JSON parse error: {0}")]
+    Json(#[from] serde_json::Error),
+
+    #[error("Graph encode/decode error: {0}")]
+    Graph(#[from] raphtory::errors::GraphError),
+
+    #[error("An error when parsing Jinja query templates: {0}")]
+    JinjaError(String),
+
+    #[error("The request did not succeed.")]
+    UnsuccessfulResponse,
+}
diff --git a/raphtory-graphql/src/client/mod.rs b/raphtory-graphql/src/client/mod.rs
new file mode 100644
index 0000000000..8eaf1cf6f8
--- /dev/null
+++ b/raphtory-graphql/src/client/mod.rs
@@ -0,0 +1,166 @@
+//! Pure Rust GraphQL client for Raphtory GraphQL server.
+
+mod error;
+pub mod raphtory_client;
+pub mod remote_edge;
+pub mod remote_graph;
+pub mod remote_node;
+
+pub use error::ClientError;
+pub use remote_edge::GraphQLRemoteEdge;
+pub use remote_graph::GraphQLRemoteGraph;
+pub use remote_node::GraphQLRemoteNode;
+
+use raphtory_api::core::entities::properties::prop::Prop;
+use std::collections::HashMap;
+
+/// Check if a server at the given URL is online (responds with 200).
+pub fn is_online(url: &str) -> bool {
+    reqwest::blocking::Client::new()
+        .get(url)
+        .send()
+        .map(|response| response.status().as_u16() == 200)
+        .unwrap_or(false)
+}
+
+pub(crate) fn inner_collection(value: &Prop) -> String {
+    match value {
+        Prop::Str(value) => format!("{{ str: {} }}", serde_json::to_string(value).unwrap()),
+        Prop::U8(value) => format!("{{ u8: {} }}", value),
+        Prop::U16(value) => format!("{{ u16: {} }}", value),
+        Prop::I32(value) => format!("{{ i32: {} }}", value),
+        Prop::I64(value) => format!("{{ i64: {} }}", value),
+        Prop::U32(value) => format!("{{ u32: {} }}", value),
+        Prop::U64(value) => format!("{{ u64: {} }}", value),
+        Prop::F32(value) => format!("{{ f32: {} }}", value),
+        Prop::F64(value) => format!("{{ f64: {} }}", value),
+        Prop::Bool(value) => format!("{{ bool: {} }}", value),
+        Prop::List(value) => {
+            let vec: Vec<String> = value.iter().map(|p| inner_collection(&p)).collect();
+            format!("{{ list: [{}] }}", vec.join(", "))
+        }
+        Prop::Map(value) => {
+            let properties_array: Vec<String> = value
+                .iter()
+                .map(|(k, v)| {
+                    format!(
+                        "{{ key: {}, value: {} }}",
+                        serde_json::to_string(k).unwrap(),
+                        inner_collection(v)
+                    )
+                })
+                .collect();
+            format!("{{ object: [{}] }}", properties_array.join(", "))
+        }
+        Prop::DTime(dt) => format!("{{ dtime: \"{}\" }}", dt.to_rfc3339()),
+        Prop::NDTime(ndt) => format!(
+            "{{ ndtime: \"{}\" }}",
+            ndt.format("%Y-%m-%dT%H:%M:%S%.3f").to_string()
+        ),
+        Prop::Decimal(value) => format!("{{ decimal: \"{}\" }}", value.to_string()),
+    }
+}
+
+fn to_graphql_valid(key: &String, value: &Prop) -> String {
+    match value {
+        Prop::Str(value) => format!(
+            "{{ key: {}, value: {{ str: {} }} }}",
+            serde_json::to_string(key).unwrap(),
+            serde_json::to_string(value).unwrap()
+        ),
+        Prop::U8(value) => format!(
+            "{{ key: {}, value: {{ u8: {} }} }}",
+            serde_json::to_string(key).unwrap(),
+            value
+        ),
+        Prop::U16(value) => format!(
+            "{{ key: {}, value: {{ u16: {} }} }}",
+            serde_json::to_string(key).unwrap(),
+            value
+        ),
+        Prop::I32(value) => format!(
+            "{{ key: {}, value: {{ i32: {} }} }}",
+            serde_json::to_string(key).unwrap(),
+            value
+        ),
+        Prop::I64(value) => format!(
+            "{{ key: {}, value: {{ i64: {} }} }}",
+            serde_json::to_string(key).unwrap(),
+            value
+        ),
+        Prop::U32(value) => format!(
+            "{{ key: {}, value: {{ u32: {} }} }}",
+            serde_json::to_string(key).unwrap(),
+            value
+        ),
+        Prop::U64(value) => format!(
+            "{{ key: {}, value: {{ u64: {} }} }}",
+            serde_json::to_string(key).unwrap(),
+            value
+        ),
+        Prop::F32(value) => format!(
+            "{{ key: {}, value: {{ f32: {} }} }}",
+            serde_json::to_string(key).unwrap(),
+            value
+        ),
+        Prop::F64(value) => format!(
+            "{{ key: {}, value: {{ f64: {} }} }}",
+            serde_json::to_string(key).unwrap(),
+            value
+        ),
+        Prop::Bool(value) => format!(
+            "{{ key: {}, value: {{ bool: {} }} }}",
+            serde_json::to_string(key).unwrap(),
+            value
+        ),
+        Prop::List(value) => {
+            let vec: Vec<String> = value.iter().map(|p| inner_collection(&p)).collect();
+            format!(
+                "{{ key: {}, value: {{ list: [{}] }} }}",
+                serde_json::to_string(key).unwrap(),
+                vec.join(", ")
+            )
+        }
+        Prop::Map(value) => {
+            let properties_array: Vec<String> = value
+                .iter()
+                .map(|(k, v)| {
+                    format!(
+                        "{{ key: {}, value: {} }}",
+                        serde_json::to_string(k).unwrap(),
+                        inner_collection(v)
+                    )
+                })
+                .collect();
+            format!(
+                "{{ key: {}, value: {{ object: [{}] }} }}",
+                serde_json::to_string(key).unwrap(),
+                properties_array.join(", ")
+            )
+        }
+        Prop::DTime(dt) => format!(
+            "{{ key: {}, value: {{ dtime: \"{}\" }} }}",
+            serde_json::to_string(key).unwrap(),
+            dt.to_rfc3339()
+        ),
+        Prop::NDTime(ndt) => format!(
+            "{{ key: {}, value: {{ ndtime: \"{}\" }} }}",
+            serde_json::to_string(key).unwrap(),
+            ndt.format("%Y-%m-%dT%H:%M:%S%.3f").to_string()
+        ),
+        Prop::Decimal(value) => format!(
+            "{{ key: {}, value: {{ decimal: \"{}\" }} }}",
+            serde_json::to_string(key).unwrap(),
+            value.to_string()
+        ),
+    }
+}
+
+pub(crate) fn build_property_string(properties: HashMap<String, Prop>) -> String {
+    let properties_array: Vec<String> = properties
+        .iter()
+        .map(|(k, v)| to_graphql_valid(k, v))
+        .collect();
+
+    format!("[{}]", properties_array.join(", "))
+}
diff --git a/raphtory-graphql/src/client/raphtory_client.rs b/raphtory-graphql/src/client/raphtory_client.rs
new file mode 100644
index 0000000000..c8af4c36ae
--- /dev/null
+++ b/raphtory-graphql/src/client/raphtory_client.rs
@@ -0,0 +1,377 @@
+use crate::{
+    client::{ClientError, GraphQLRemoteGraph},
+    url_encode::url_decode_graph,
+};
+use raphtory::{db::api::view::MaterializedGraph, prelude::Config, serialise::GraphFolder};
+use reqwest::{multipart, multipart::Part, Client};
+use serde_json::{json, Value as JsonValue};
+use std::{collections::HashMap, io::Cursor};
+use url::Url;
+
+/// Pure Rust client for Raphtory GraphQL operations.
+#[derive(Clone, Debug)]
+pub struct RaphtoryGraphQLClient {
+    pub(crate) url: Url,
+    pub(crate) token: String,
+    client: Client,
+}
+
+impl RaphtoryGraphQLClient {
+    /// Create a new client. Does not perform a connectivity check; use [`client::is_online`] first if needed.
+    pub fn new(url: Url, token: Option<String>) -> Self {
+        Self {
+            url,
+            token: token.unwrap_or_default(),
+            client: Client::new(),
+        }
+    }
+
+    /// Create a new client and verify the server is reachable (GET url, expect 200).
+    /// Returns an error if the server is not reachable.
+    pub async fn connect(url: Url, token: Option<String>) -> Result<Self, ClientError> {
+        let token = token.unwrap_or_default();
+        let client = Client::new();
+
+        let response = client
+            .get(url.clone())
+            .bearer_auth(&token)
+            .send()
+            .await
+            .map_err(|e| {
+                ClientError::HttpError(format!(
+                    "Could not connect to the given server - no response --{e}"
+                ))
+            })?;
+        if response.status() != 200 {
+            let text = response.text().await.unwrap_or_default();
+            return Err(ClientError::HttpError(format!(
+                "Could not connect to the given server - response {}",
+                text
+            )));
+        }
+
+        Ok(Self { url, token, client })
+    }
+
+    /// Returns true if the server could be reached and returns a healthy response.
+    pub async fn is_healthy(&self) -> bool {
+        let health_url = self.url.join("health").expect("couldn't create health url");
+
+        let response_res = self
+            .client
+            .get(health_url)
+            .bearer_auth(&self.token)
+            .send()
+            .await;
+
+        if let Ok(response) = response_res {
+            if response.status().is_success() {
+                if let Ok(v) = response.json::<JsonValue>().await {
+                    if v.get("healthy") == Some(&JsonValue::Bool(true)) {
+                        return true;
+                    }
+                }
+            }
+        }
+
+        false
+    }
+
+    /// Execute a GraphQL query asynchronously.
+    /// Returns the `data` object as a map; errors if the response contains GraphQL `errors`.
+    pub async fn query(
+        &self,
+        query: &str,
+        variables: HashMap<String, JsonValue>,
+    ) -> Result<HashMap<String, JsonValue>, ClientError> {
+        let request_body = json!({
+            "query": query,
+            "variables": variables
+        });
+
+        let response = self
+            .client
+            .post(self.url.clone())
+            .bearer_auth(&self.token)
+            .json(&request_body)
+            .send()
+            .await?;
+
+        if !response.status().is_success() {
+            let status = response.status().as_u16();
+            let text = response.text().await.unwrap_or_default();
+            return Err(ClientError::HttpError(format!(
+                "HTTP error: status {status}, body: {text}"
+            )));
+        }
+
+        let mut graphql_result: HashMap<String, JsonValue> = response.json().await?;
+
+        if let Some(errors) = graphql_result.remove("errors") {
+            let message = match errors {
+                JsonValue::Array(errors) => errors
+                    .iter()
+                    .map(|e| format!("{}", e))
+                    .collect::<Vec<_>>()
+                    .join("\n\t"),
+                _ => format!("{}", errors),
+            };
+            return Err(ClientError::GraphQLErrors(format!(
+                "After sending query to the server:\n\t{}\nGot the following errors:\n\t{}",
+                query, message
+            )));
+        }
+
+        match graphql_result.remove("data") {
+            Some(JsonValue::Object(data)) => Ok(data.into_iter().collect()),
+            _ => Err(ClientError::InvalidResponse(format!(
+                "Error while reading server response for query:\n\t{query}"
+            ))),
+        }
+    }
+
+    /// Send a graph (base64-encoded string) to the server.
+    pub async fn send_graph(
+        &self,
+        path: &str,
+        encoded_graph: &str,
+        overwrite: bool,
+    ) -> Result<(), ClientError> {
+        let query = r#"
+            mutation SendGraph($path: String!, $graph: String!, $overwrite: Boolean!) {
+                sendGraph(path: $path, graph: $graph, overwrite: $overwrite)
+            }
+        "#
+        .to_owned();
+        let variables: HashMap<String, JsonValue> = [
+            ("path".to_owned(), json!(path)),
+            ("graph".to_owned(), json!(encoded_graph)),
+            ("overwrite".to_owned(), json!(overwrite)),
+        ]
+        .into_iter()
+        .collect();
+
+        let data = self.query(&query, variables).await?;
+        match data.get("sendGraph") {
+            Some(JsonValue::String(_)) => Ok(()),
+            _ => Err(ClientError::InvalidResponse(format!(
+                "Error Sending Graph. Got response {:?}",
+                data
+            ))),
+        }
+    }
+
+    /// Upload a graph from a local file path (zip) via multipart.
+    pub async fn upload_graph(
+        &self,
+        path: &str,
+        file_path: &str,
+        overwrite: bool,
+    ) -> Result<(), ClientError> {
+        let folder = GraphFolder::from(file_path);
+        let mut buffer = Vec::new();
+        folder.zip_from_folder(Cursor::new(&mut buffer))?;
+
+        let variables = format!(
+            r#""path": "{}", "overwrite": {}, "graph": null"#,
+            path, overwrite
+        );
+        let operations = format!(
+            r#"{{
+            "query": "mutation UploadGraph($path: String!, $graph: Upload!, $overwrite: Boolean!) {{ uploadGraph(path: $path, graph: $graph, overwrite: $overwrite) }}",
+            "variables": {{ {} }}
+        }}"#,
+            variables
+        );
+
+        let form = multipart::Form::new()
+            .text("operations", operations)
+            .text("map", r#"{"0": ["variables.graph"]}"#)
+            .part("0", Part::bytes(buffer).file_name(file_path.to_string()));
+
+        let response = self
+            .client
+            .post(self.url.clone())
+            .bearer_auth(&self.token)
+            .multipart(form)
+            .send()
+            .await?;
+
+        let status = response.status();
+        let text = response.text().await?;
+
+        if !status.is_success() {
+            return Err(ClientError::HttpError(format!(
+                "Error Uploading Graph. Status: {}. Response: {}",
+                status.as_u16(),
+                text
+            )));
+        }
+
+        let mut data: HashMap<String, JsonValue> = serde_json::from_str(&text)?;
+        match data.remove("data") {
+            Some(JsonValue::Object(_)) => Ok(()),
+            _ => match data.remove("errors") {
+                Some(JsonValue::Array(errors)) => Err(ClientError::GraphQLErrors(format!(
+                    "Error Uploading Graph. Got errors:\n\t{:#?}",
+                    errors
+                ))),
+                _ => Err(ClientError::InvalidResponse(format!(
+                    "Error Uploading Graph. Unexpected response: {}",
+                    text
+                ))),
+            },
+        }
+    }
+
+    /// Copy graph on the server.
+    pub async fn copy_graph(&self, path: &str, new_path: &str) -> Result<(), ClientError> {
+        let query = r#"
+            mutation CopyGraph($path: String!, $newPath: String!) {
+              copyGraph(path: $path, newPath: $newPath)
+            }"#
+        .to_owned();
+        let variables: HashMap<String, JsonValue> = [
+            ("path".to_owned(), json!(path)),
+            ("newPath".to_owned(), json!(new_path)),
+        ]
+        .into_iter()
+        .collect();
+
+        let data = self.query(&query, variables).await?;
+        match data.get("copyGraph") {
+            Some(JsonValue::Bool(true)) => Ok(()),
+            _ => Err(ClientError::InvalidResponse(format!(
+                "Error while reading server response for query:\n\t{query}\nGot data:\n\t'{data:?}'"
+            ))),
+        }
+    }
+
+    /// Move graph on the server.
+    pub async fn move_graph(&self, path: &str, new_path: &str) -> Result<(), ClientError> {
+        let query = r#"
+            mutation MoveGraph($path: String!, $newPath: String!) {
+              moveGraph(path: $path, newPath: $newPath)
+            }"#
+        .to_owned();
+        let variables: HashMap<String, JsonValue> = [
+            ("path".to_owned(), json!(path)),
+            ("newPath".to_owned(), json!(new_path)),
+        ]
+        .into_iter()
+        .collect();
+
+        let data = self.query(&query, variables).await?;
+        match data.get("moveGraph") {
+            Some(JsonValue::Bool(true)) => Ok(()),
+            _ => Err(ClientError::InvalidResponse(format!(
+                "Error while reading server response for query:\n\t{query}\nGot data:\n\t'{data:?}'"
+            ))),
+        }
+    }
+
+    /// Delete graph on the server.
+    pub async fn delete_graph(&self, path: &str) -> Result<(), ClientError> {
+        let query = r#"
+            mutation DeleteGraph($path: String!) {
+              deleteGraph(path: $path)
+            }"#
+        .to_owned();
+        let variables: HashMap<String, JsonValue> =
+            [("path".to_owned(), json!(path))].into_iter().collect();
+
+        let data = self.query(&query, variables).await?;
+        match data.get("deleteGraph") {
+            Some(JsonValue::Bool(true)) => Ok(()),
+            _ => Err(ClientError::InvalidResponse(format!(
+                "Error while reading server response for query:\n\t{query}\nGot data:\n\t'{data:?}'"
+            ))),
+        }
+    }
+
+    /// Receive graph from the server. Returns the base64-encoded graph string.
+    pub async fn receive_graph(&self, path: &str) -> Result<String, ClientError> {
+        let query = r#"
+            query ReceiveGraph($path: String!) {
+                receiveGraph(path: $path)
+            }"#
+        .to_owned();
+        let variables: HashMap<String, JsonValue> =
+            [("path".to_owned(), json!(path))].into_iter().collect();
+
+        let data = self.query(&query, variables).await?;
+        match data.get("receiveGraph") {
+            Some(JsonValue::String(s)) => Ok(s.clone()),
+            _ => Err(ClientError::InvalidResponse(format!(
+                "Error while reading server response for query:\n\t{query}\nGot data:\n\t'{data:?}'"
+            ))),
+        }
+    }
+
+    /// Receive graph from the server and decode to MaterializedGraph.
+    pub async fn receive_graph_decoded(
+        &self,
+        path: &str,
+    ) -> Result<MaterializedGraph, ClientError> {
+        let encoded = self.receive_graph(path).await?;
+        url_decode_graph(encoded, Config::default()).map_err(ClientError::from)
+    }
+
+    /// Create a new empty graph on the server.
+    pub async fn new_graph(&self, path: &str, graph_type: &str) -> Result<(), ClientError> {
+        let query = r#"
+            mutation NewGraph($path: String!) {
+              newGraph(path: $path, graphType: EVENT)
+            }"#
+        .to_owned()
+        .replace("EVENT", graph_type);
+
+        let variables: HashMap<String, JsonValue> =
+            [("path".to_owned(), json!(path))].into_iter().collect();
+
+        let data = self.query(&query, variables).await?;
+        match data.get("newGraph") {
+            Some(JsonValue::Bool(true)) => Ok(()),
+            _ => Err(ClientError::InvalidResponse(format!(
+                "Error while reading server response for query:\n\t{query}\nGot data:\n\t'{data:?}'"
+            ))),
+        }
+    }
+
+    pub fn remote_graph(&self, path: String) -> GraphQLRemoteGraph {
+        GraphQLRemoteGraph::new(path, self.clone())
+    }
+
+    /// Create index on the server. `index_spec` must serialize to a value
+    /// compatible with the GraphQL `IndexSpecInput` type.
+    pub async fn create_index(
+        &self,
+        path: &str,
+        index_spec: JsonValue,
+        in_ram: bool,
+    ) -> Result<(), ClientError> {
+        let query = r#"
+            mutation CreateIndex($path: String!, $indexSpec: IndexSpecInput!, $inRam: Boolean!) {
+                createIndex(path: $path, indexSpec: $indexSpec, inRam: $inRam)
+            }
+        "#
+        .to_owned();
+
+        let variables: HashMap<String, JsonValue> = [
+            ("path".to_string(), json!(path)),
+            ("indexSpec".to_string(), index_spec),
+            ("inRam".to_string(), json!(in_ram)),
+        ]
+        .into_iter()
+        .collect();
+
+        let data = self.query(&query, variables).await?;
+        match data.get("createIndex") {
+            Some(JsonValue::Bool(true)) => Ok(()),
+            _ => Err(ClientError::InvalidResponse(format!(
+                "Failed to create index, server returned: {:?}",
+                data
+            ))),
+        }
+    }
+}
diff --git a/raphtory-graphql/src/client/remote_edge.rs b/raphtory-graphql/src/client/remote_edge.rs
new file mode 100644
index 0000000000..fcacc74e5e
--- /dev/null
+++ b/raphtory-graphql/src/client/remote_edge.rs
@@ -0,0 +1,145 @@
+//! Pure Rust remote edge client for GraphQL updateGraph.edge(...) operations.
+
+use crate::client::{
+    build_property_string, raphtory_client::RaphtoryGraphQLClient, remote_graph::build_query,
+    ClientError,
+};
+use minijinja::context;
+use raphtory_api::core::{
+    entities::properties::prop::Prop, storage::timeindex::AsTime, utils::time::IntoTime,
+};
+use std::collections::HashMap;
+
+/// Pure Rust remote edge wrapper around `RaphtoryGraphQLClient`.
+#[derive(Clone)]
+pub struct GraphQLRemoteEdge {
+    pub path: String,
+    pub client: RaphtoryGraphQLClient,
+    pub src: String,
+    pub dst: String,
+}
+
+impl GraphQLRemoteEdge {
+    pub fn new(path: String, client: RaphtoryGraphQLClient, src: String, dst: String) -> Self {
+        Self {
+            path,
+            client,
+            src,
+            dst,
+        }
+    }
+
+    /// Add temporal updates to the edge at the specified time.
+    pub async fn add_updates<T: IntoTime>(
+        &self,
+        t: T,
+        properties: Option<HashMap<String, Prop>>,
+        layer: Option<String>,
+    ) -> Result<(), ClientError> {
+        let template = r#"
+            {
+              updateGraph(path: "{{path}}") {
+                edge(src: "{{src}}",dst: "{{dst}}") {
+                  addUpdates(time: {{t}} {% if properties is not none %}, properties: {{ properties | safe }} {% endif %} {% if layer is not none %}, layer:  "{{layer}}" {% endif %})
+                }
+              }
+            }
+        "#;
+
+        let ctx = context! {
+            path => self.path,
+            src => self.src,
+            dst => self.dst,
+            t => t.into_time().t(),
+            properties => properties.map(|p| build_property_string(p)),
+            layer => layer
+        };
+
+        let query = build_query(template, ctx).map_err(ClientError::from)?;
+        self.client.query(&query, HashMap::new()).await.map(|_| ())
+    }
+
+    /// Mark the edge as deleted at the specified time.
+    pub async fn delete<T: IntoTime>(
+        &self,
+        t: T,
+        layer: Option<String>,
+    ) -> Result<(), ClientError> {
+        let template = r#"
+            {
+              updateGraph(path: "{{path}}") {
+                edge(src: "{{src}}",dst: "{{dst}}") {
+                  delete(time: {{t}}{% if layer is not none %}, layer:  "{{layer}}"{% endif %})
+                }
+              }
+            }
+        "#;
+
+        let ctx = context! {
+            path => self.path,
+            src => self.src,
+            dst => self.dst,
+            t => t.into_time().t(),
+            layer => layer
+        };
+
+        let query = build_query(template, ctx).map_err(ClientError::from)?;
+        self.client.query(&query, HashMap::new()).await.map(|_| ())
+    }
+
+    /// Add metadata to the edge (properties that do not change over time).
+    pub async fn add_metadata(
+        &self,
+        properties: HashMap<String, Prop>,
+        layer: Option<String>,
+    ) -> Result<(), ClientError> {
+        let template = r#"
+            {
+              updateGraph(path: "{{path}}") {
+                edge(src: "{{src}}",dst: "{{dst}}") {
+                  addMetadata(properties:  {{ properties | safe }} {% if layer is not none %}, layer:  "{{layer}}" {% endif %})
+                }
+              }
+            }
+        "#;
+
+        let ctx = context! {
+            path => self.path,
+            src => self.src,
+            dst => self.dst,
+            properties => build_property_string(properties),
+            layer => layer
+        };
+
+        let query = build_query(template, ctx).map_err(ClientError::from)?;
+        self.client.query(&query, HashMap::new()).await.map(|_| ())
+    }
+
+    /// Update metadata of the edge, overwriting existing values.
+    pub async fn update_metadata(
+        &self,
+        properties: HashMap<String, Prop>,
+        layer: Option<String>,
+    ) -> Result<(), ClientError> {
+        let template = r#"
+            {
+              updateGraph(path: "{{path}}") {
+                edge(src: "{{src}}",dst: "{{dst}}") {
+                  updateMetadata(properties:  {{ properties | safe }} {% if layer is not none %}, layer:  "{{layer}}" {% endif %})
+                }
+              }
+            }
+        "#;
+
+        let ctx = context! {
+            path => self.path,
+            src => self.src,
+            dst => self.dst,
+            properties => build_property_string(properties),
+            layer => layer
+        };
+
+        let query = build_query(template, ctx).map_err(ClientError::from)?;
+        self.client.query(&query, HashMap::new()).await.map(|_| ())
+    }
+}
diff --git a/raphtory-graphql/src/client/remote_graph.rs b/raphtory-graphql/src/client/remote_graph.rs
new file mode 100644
index 0000000000..de8ab115bd
--- /dev/null
+++ b/raphtory-graphql/src/client/remote_graph.rs
@@ -0,0 +1,336 @@
+use crate::client::{
+    build_property_string, raphtory_client::RaphtoryGraphQLClient, remote_edge::GraphQLRemoteEdge,
+    remote_node::GraphQLRemoteNode, ClientError,
+};
+use minijinja::{context, Environment, Value};
+use raphtory_api::core::{
+    entities::{properties::prop::Prop, GID},
+    storage::timeindex::{AsTime, EventTime},
+    utils::time::IntoTime,
+};
+use std::collections::HashMap;
+
+pub fn build_query(template: &str, context: Value) -> Result<String, ClientError> {
+    let mut env = Environment::new();
+    env.add_template("template", template)
+        .map_err(|e| ClientError::JinjaError(e.to_string()))?;
+    let query = env
+        .get_template("template")
+        .map_err(|e| ClientError::JinjaError(e.to_string()))?
+        .render(context)
+        .map_err(|e| ClientError::JinjaError(e.to_string()))?;
+    Ok(query)
+}
+
+/// Pure Rust remote graph wrapper around `RaphtoryGraphQLClient`.
+#[derive(Clone)]
+pub struct GraphQLRemoteGraph {
+    pub path: String,
+    pub client: RaphtoryGraphQLClient,
+}
+
+impl GraphQLRemoteGraph {
+    pub fn new(path: String, client: RaphtoryGraphQLClient) -> Self {
+        Self { path, client }
+    }
+
+    /// Returns a remote node reference for the given node id.
+    pub fn node(&self, id: impl ToString) -> GraphQLRemoteNode {
+        GraphQLRemoteNode::new(self.path.clone(), self.client.clone(), id.to_string())
+    }
+
+    /// Returns a remote edge reference for the given source and destination node ids.
+    pub fn edge(&self, src: impl ToString, dst: impl ToString) -> GraphQLRemoteEdge {
+        GraphQLRemoteEdge::new(
+            self.path.clone(),
+            self.client.clone(),
+            src.to_string(),
+            dst.to_string(),
+        )
+    }
+
+    pub async fn add_node<G: Into<GID> + ToString, T: IntoTime>(
+        &self,
+        timestamp: T,
+        id: G,
+        properties: Option<HashMap<String, Prop>>,
+        node_type: Option<String>,
+    ) -> Result<GraphQLRemoteNode, ClientError> {
+        let template = r#"
+        {
+            updateGraph(path: "{{ path }}") {
+                addNode(time: {{ time }}, name: "{{ name }}" {% if properties is not none %}, properties:  {{ properties | safe }} {% endif %}{% if node_type is not none %}, nodeType: "{{ node_type }}"{% endif %}) {
+                    success
+                }
+            }
+        }
+        "#;
+
+        let ctx = context! {
+            path => self.path,
+            time => timestamp.into_time().t(),
+            name => id.to_string(),
+            properties => properties.map(|p| build_property_string(p)),
+            node_type => node_type,
+        };
+
+        let query = build_query(template, ctx)?;
+        let res = self.client.query(&query, HashMap::new()).await?;
+        if res
+            .get("updateGraph")
+            .and_then(|x| x.as_object())
+            .and_then(|x| x.get("addNode"))
+            .and_then(|x| x.as_object())
+            .and_then(|x| x.get("success"))
+            .and_then(|x| x.as_bool())
+            .is_some_and(|x| x == true)
+        {
+            Ok(GraphQLRemoteNode::new(
+                self.path.clone(),
+                self.client.clone(),
+                id.to_string(),
+            ))
+        } else {
+            Err(ClientError::UnsuccessfulResponse)
+        }
+    }
+
+    /// Create a new node (fails if the node already exists). Uses the createNode mutation.
+    pub async fn create_node<G: Into<GID> + ToString, T: IntoTime>(
+        &self,
+        timestamp: T,
+        id: G,
+        properties: Option<HashMap<String, Prop>>,
+        node_type: Option<String>,
+    ) -> Result<GraphQLRemoteNode, ClientError> {
+        let template = r#"
+        {
+            updateGraph(path: "{{ path }}") {
+                createNode(time: {{ time }}, name: "{{ name }}" {% if properties is not none %}, properties:  {{ properties | safe }} {% endif %}{% if node_type is not none %}, nodeType: "{{ node_type }}"{% endif %}) {
+                    success
+                }
+            }
+        }
+        "#;
+
+        let ctx = context! {
+            path => self.path,
+            time => timestamp.into_time().t(),
+            name => id.to_string(),
+            properties => properties.map(|p| build_property_string(p)),
+            node_type => node_type,
+        };
+
+        let query = build_query(template, ctx)?;
+        let res = self.client.query(&query, HashMap::new()).await?;
+        if res
+            .get("updateGraph")
+            .and_then(|x| x.as_object())
+            .and_then(|x| x.get("createNode"))
+            .and_then(|x| x.as_object())
+            .and_then(|x| x.get("success"))
+            .and_then(|x| x.as_bool())
+            .is_some_and(|x| x == true)
+        {
+            Ok(GraphQLRemoteNode::new(
+                self.path.clone(),
+                self.client.clone(),
+                id.to_string(),
+            ))
+        } else {
+            Err(ClientError::UnsuccessfulResponse)
+        }
+    }
+
+    pub async fn add_edge<G: Into<GID> + ToString, T: IntoTime>(
+        &self,
+        timestamp: T,
+        src: G,
+        dst: G,
+        properties: Option<HashMap<String, Prop>>,
+        layer: Option<String>,
+    ) -> Result<GraphQLRemoteEdge, ClientError> {
+        let template = r#"
+        {
+            updateGraph(path: "{{ path }}") {
+                addEdge(time: {{ time }}, src: "{{ src }}", dst: "{{ dst }}" {% if properties is not none %}, properties:  {{ properties | safe }} {% endif %}{% if layer is not none %}, layer: "{{ layer }}"{% endif %}) {
+                    success
+                }
+            }
+        }
+        "#;
+
+        let ctx = context! {
+            path => self.path,
+            time => timestamp.into_time().t(),
+            src => src.to_string(),
+            dst => dst.to_string(),
+            properties => properties.map(|p| build_property_string(p)),
+            layer => layer,
+        };
+
+        let query = build_query(template, ctx)?;
+        let res = self.client.query(&query, HashMap::new()).await?;
+        if res
+            .get("updateGraph")
+            .and_then(|x| x.as_object())
+            .and_then(|x| x.get("addEdge"))
+            .and_then(|x| x.as_object())
+            .and_then(|x| x.get("success"))
+            .and_then(|x| x.as_bool())
+            .is_some_and(|x| x == true)
+        {
+            Ok(GraphQLRemoteEdge::new(
+                self.path.clone(),
+                self.client.clone(),
+                src.to_string(),
+                dst.to_string(),
+            ))
+        } else {
+            Err(ClientError::UnsuccessfulResponse)
+        }
+    }
+
+    pub async fn add_property(
+        &self,
+        timestamp: EventTime,
+        properties: HashMap<String, Prop>,
+    ) -> Result<(), ClientError> {
+        let template = r#"
+        {
+          updateGraph(path: "{{ path }}") {
+            addProperties(t: {{t}} properties: {{ properties | safe }})
+          }
+        }
+        "#;
+
+        let ctx = context! {
+            path => self.path,
+            t => timestamp.into_time().t(),
+            properties => build_property_string(properties),
+        };
+
+        let query = build_query(template, ctx)?;
+        let res = self.client.query(&query, HashMap::new()).await?;
+        if res
+            .get("updateGraph")
+            .and_then(|x| x.as_object())
+            .and_then(|x| x.get("addProperties"))
+            .and_then(|x| x.as_bool())
+            .is_some_and(|x| x == true)
+        {
+            Ok(())
+        } else {
+            Err(ClientError::UnsuccessfulResponse)
+        }
+    }
+
+    pub async fn add_metadata(&self, properties: HashMap<String, Prop>) -> Result<(), ClientError> {
+        let template = r#"
+        {
+          updateGraph(path: "{{ path }}") {
+            addMetadata(properties: {{ properties | safe }})
+          }
+        }
+        "#;
+
+        let ctx = context! {
+            path => self.path,
+            properties => build_property_string(properties),
+        };
+
+        let query = build_query(template, ctx)?;
+        let res = self.client.query(&query, HashMap::new()).await?;
+        if res
+            .get("updateGraph")
+            .and_then(|x| x.as_object())
+            .and_then(|x| x.get("addMetadata"))
+            .and_then(|x| x.as_bool())
+            .is_some_and(|x| x == true)
+        {
+            Ok(())
+        } else {
+            Err(ClientError::UnsuccessfulResponse)
+        }
+    }
+
+    pub async fn update_metadata(
+        &self,
+        properties: HashMap<String, Prop>,
+    ) -> Result<(), ClientError> {
+        let template = r#"
+        {
+          updateGraph(path: "{{ path }}") {
+            updateMetadata(properties: {{ properties | safe }})
+          }
+        }
+        "#;
+
+        let ctx = context! {
+            path => self.path,
+            properties => build_property_string(properties),
+        };
+
+        let query = build_query(template, ctx)?;
+        let res = self.client.query(&query, HashMap::new()).await?;
+        if res
+            .get("updateGraph")
+            .and_then(|x| x.as_object())
+            .and_then(|x| x.get("updateMetadata"))
+            .and_then(|x| x.as_bool())
+            .is_some_and(|x| x == true)
+        {
+            Ok(())
+        } else {
+            Err(ClientError::UnsuccessfulResponse)
+        }
+    }
+
+    /// Deletes an edge at the given time, src, dst and optional layer.
+    pub async fn delete_edge<G: Into<GID> + ToString, T: IntoTime>(
+        &self,
+        timestamp: T,
+        src: G,
+        dst: G,
+        layer: Option<String>,
+    ) -> Result<GraphQLRemoteEdge, ClientError> {
+        let template = r#"
+        {
+            updateGraph(path: "{{ path }}") {
+                deleteEdge(time: {{ time }}, src: "{{ src }}", dst: "{{ dst }}" {% if layer is not none %}, layer: "{{ layer }}"{% endif %}) {
+                    success
+                }
+            }
+        }
+        "#;
+
+        let ctx = context! {
+            path => self.path,
+            time => timestamp.into_time().t(),
+            src => src.to_string(),
+            dst => dst.to_string(),
+            layer => layer,
+        };
+
+        let query = build_query(template, ctx)?;
+        let res = self.client.query(&query, HashMap::new()).await?;
+        if res
+            .get("updateGraph")
+            .and_then(|x| x.as_object())
+            .and_then(|x| x.get("deleteEdge"))
+            .and_then(|x| x.as_object())
+            .and_then(|x| x.get("success"))
+            .and_then(|x| x.as_bool())
+            .is_some_and(|x| x == true)
+        {
+            Ok(GraphQLRemoteEdge::new(
+                self.path.clone(),
+                self.client.clone(),
+                src.to_string(),
+                dst.to_string(),
+            ))
+        } else {
+            Err(ClientError::UnsuccessfulResponse)
+        }
+    }
+}
diff --git a/raphtory-graphql/src/client/remote_node.rs b/raphtory-graphql/src/client/remote_node.rs
new file mode 100644
index 0000000000..66bfcd0607
--- /dev/null
+++ b/raphtory-graphql/src/client/remote_node.rs
@@ -0,0 +1,121 @@
+//! Pure Rust remote node client for GraphQL updateGraph.node(...) operations.
+
+use crate::client::{
+    build_property_string, raphtory_client::RaphtoryGraphQLClient, remote_graph::build_query,
+    ClientError,
+};
+use minijinja::context;
+use raphtory_api::core::{
+    entities::properties::prop::Prop, storage::timeindex::AsTime, utils::time::IntoTime,
+};
+use std::collections::HashMap;
+
+/// Pure Rust remote node wrapper around `RaphtoryGraphQLClient`.
+#[derive(Clone)]
+pub struct GraphQLRemoteNode {
+    pub path: String,
+    pub client: RaphtoryGraphQLClient,
+    pub id: String,
+}
+
+impl GraphQLRemoteNode {
+    pub fn new(path: String, client: RaphtoryGraphQLClient, id: String) -> Self {
+        Self { path, client, id }
+    }
+
+    /// Set the type on the node. This only works if the type has not been previously set.
+    pub async fn set_node_type(&self, new_type: String) -> Result<(), ClientError> {
+        let template = r#"
+            {
+              updateGraph(path: "{{path}}") {
+                node(name: "{{name}}") {
+                  setNodeType(newType: "{{new_type}}")
+                }
+              }
+            }
+        "#;
+
+        let ctx = context! {
+            path => self.path,
+            name => self.id,
+            new_type => new_type
+        };
+
+        let query = build_query(template, ctx).map_err(ClientError::from)?;
+        self.client.query(&query, HashMap::new()).await.map(|_| ())
+    }
+
+    /// Add temporal updates to the node at the specified time.
+    pub async fn add_updates<T: IntoTime>(
+        &self,
+        t: T,
+        properties: Option<HashMap<String, Prop>>,
+    ) -> Result<(), ClientError> {
+        let template = r#"
+            {
+              updateGraph(path: "{{path}}") {
+                node(name: "{{name}}") {
+                  addUpdates(time: {{t}} {% if properties is not none %}, properties:  {{ properties | safe }} {% endif %})
+                }
+              }
+            }
+        "#;
+
+        let ctx = context! {
+            path => self.path,
+            name => self.id,
+            t => t.into_time().t(),
+            properties => properties.map(|p| build_property_string(p)),
+        };
+
+        let query = build_query(template, ctx).map_err(ClientError::from)?;
+        self.client.query(&query, HashMap::new()).await.map(|_| ())
+    }
+
+    /// Add metadata to the node (properties that do not change over time).
+    pub async fn add_metadata(&self, properties: HashMap<String, Prop>) -> Result<(), ClientError> {
+        let template = r#"
+            {
+              updateGraph(path: "{{path}}") {
+                node(name: "{{name}}") {
+                  addMetadata(properties: {{ properties | safe }} )
+                }
+              }
+            }
+        "#;
+
+        let ctx = context! {
+            path => self.path,
+            name => self.id,
+            properties => build_property_string(properties),
+        };
+
+        let query = build_query(template, ctx).map_err(ClientError::from)?;
+        self.client.query(&query, HashMap::new()).await.map(|_| ())
+    }
+
+    /// Update metadata of the node, overwriting existing values.
+    pub async fn update_metadata(
+        &self,
+        properties: HashMap<String, Prop>,
+    ) -> Result<(), ClientError> {
+        let template = r#"
+            {
+              updateGraph(path: "{{path}}") {
+                node(name: "{{name}}") {
+                  updateMetadata(properties: {{ properties | safe }} )
+                }
+              }
+            }
+        "#;
+
+        let ctx = context! {
+            path => self.path,
+            name => self.id,
+            properties => build_property_string(properties)
+        };
+
+        let query = build_query(template, ctx).map_err(ClientError::from)?;
+        self.client.query(&query, HashMap::new()).await.map(|_| ())
+    }
+}
diff --git a/raphtory-graphql/src/config/app_config.rs b/raphtory-graphql/src/config/app_config.rs
index 9404d678e6..4157dd84df 100644
--- a/raphtory-graphql/src/config/app_config.rs
+++ b/raphtory-graphql/src/config/app_config.rs
@@ -1,6 +1,7 @@
 use super::auth_config::{AuthConfig, PublicKeyError, PUBLIC_KEY_DECODING_ERR_MSG};
 use crate::config::{
-    cache_config::CacheConfig, log_config::LoggingConfig, otlp_config::TracingConfig,
+    cache_config::CacheConfig, concurrency_config::ConcurrencyConfig, log_config::LoggingConfig,
+    otlp_config::TracingConfig, schema_config::SchemaConfig,
 };
 use config::{Config, ConfigError, File};
 use serde::{Deserialize, Serialize};
@@ -16,6 +17,8 @@ pub struct AppConfig {
     pub cache: CacheConfig,
     pub tracing: TracingConfig,
     pub auth: AuthConfig,
+    pub concurrency: ConcurrencyConfig,
+    pub schema: SchemaConfig,
     pub public_dir: Option<PathBuf>,
     #[cfg(feature = "search")]
     pub index: IndexConfig,
@@ -26,6 +29,8 @@ pub struct AppConfigBuilder {
     cache: CacheConfig,
     tracing: TracingConfig,
     auth: AuthConfig,
+    concurrency: ConcurrencyConfig,
+    schema: SchemaConfig,
     public_dir: Option<PathBuf>,
     #[cfg(feature = "search")]
     index: IndexConfig,
@@ -38,6 +43,8 @@ impl From<AppConfig> for AppConfigBuilder {
             cache: config.cache,
             tracing: config.tracing,
             auth: config.auth,
+            concurrency: config.concurrency,
+            schema: config.schema,
             public_dir: config.public_dir,
             #[cfg(feature = "search")]
             index: config.index,
@@ -106,8 +113,66 @@ impl AppConfigBuilder {
         Ok(self)
     }
 
-    pub fn with_auth_enabled_for_reads(mut self, enabled_for_reads: bool) -> Self {
-        self.auth.enabled_for_reads = enabled_for_reads;
+    pub fn with_require_auth_for_reads(mut self, require_auth_for_reads: bool) -> Self {
+        self.auth.require_auth_for_reads = require_auth_for_reads;
+        self
+    }
+
+    pub fn with_heavy_query_limit(mut self, heavy_query_limit: Option<usize>) -> Self {
+        self.concurrency.heavy_query_limit = heavy_query_limit;
+        self
+    }
+
+    pub fn with_exclusive_writes(mut self, exclusive_writes: bool) -> Self {
+        self.concurrency.exclusive_writes = exclusive_writes;
+        self
+    }
+
+    pub fn with_disable_batching(mut self, disable_batching: bool) -> Self {
+        self.concurrency.disable_batching = disable_batching;
+        self
+    }
+
+    pub fn with_max_batch_size(mut self, max_batch_size: Option<usize>) -> Self {
+        self.concurrency.max_batch_size = max_batch_size;
+        self
+    }
+
+    pub fn with_disable_lists(mut self, disable_lists: bool) -> Self {
+        self.concurrency.disable_lists = disable_lists;
+        self
+    }
+
+    pub fn with_max_page_size(mut self, max_page_size: Option<usize>) -> Self {
+        self.concurrency.max_page_size = max_page_size;
+        self
+    }
+
+    pub fn with_max_query_depth(mut self, max_query_depth: Option<usize>) -> Self {
+        self.schema.max_query_depth = max_query_depth;
+        self
+    }
+
+    pub fn with_max_query_complexity(mut self, max_query_complexity: Option<usize>) -> Self {
+        self.schema.max_query_complexity = max_query_complexity;
+        self
+    }
+
+    pub fn with_max_recursive_depth(mut self, max_recursive_depth: Option<usize>) -> Self {
+        self.schema.max_recursive_depth = max_recursive_depth;
+        self
+    }
+
+    pub fn with_max_directives_per_field(
+        mut self,
+        max_directives_per_field: Option<usize>,
+    ) -> Self {
+        self.schema.max_directives_per_field = max_directives_per_field;
+        self
+    }
+
+    pub fn with_disable_introspection(mut self, disable_introspection: bool) -> Self {
+        self.schema.disable_introspection = disable_introspection;
         self
     }
 
@@ -128,6 +193,8 @@ impl AppConfigBuilder {
             cache: self.cache,
             tracing: self.tracing,
             auth: self.auth,
+            concurrency: self.concurrency,
+            schema: self.schema,
             public_dir: self.public_dir,
             #[cfg(feature = "search")]
             index: self.index,
@@ -195,8 +262,46 @@ pub fn load_config(
             .with_auth_public_key(public_key)
             .map_err(|_| ConfigError::Message(PUBLIC_KEY_DECODING_ERR_MSG.to_owned()))?;
     }
-    if let Ok(enabled_for_reads) = settings.get::<bool>("auth.enabled_for_reads") {
-        app_config_builder = app_config_builder.with_auth_enabled_for_reads(enabled_for_reads);
+    if let Ok(require_auth_for_reads) = settings.get::<bool>("auth.require_auth_for_reads") {
+        app_config_builder = app_config_builder.with_require_auth_for_reads(require_auth_for_reads);
+    }
+
+    if let Ok(heavy_query_limit) = settings.get::<Option<usize>>("concurrency.heavy_query_limit") {
+        app_config_builder = app_config_builder.with_heavy_query_limit(heavy_query_limit);
+    }
+    if let Ok(exclusive_writes) = settings.get::<bool>("concurrency.exclusive_writes") {
+        app_config_builder = app_config_builder.with_exclusive_writes(exclusive_writes);
+    }
+    if let Ok(disable_batching) = settings.get::<bool>("concurrency.disable_batching") {
+        app_config_builder = app_config_builder.with_disable_batching(disable_batching);
+    }
+    if let Ok(max_batch_size) = settings.get::<Option<usize>>("concurrency.max_batch_size") {
+        app_config_builder = app_config_builder.with_max_batch_size(max_batch_size);
+    }
+    if let Ok(disable_lists) = settings.get::<bool>("concurrency.disable_lists") {
+        app_config_builder = app_config_builder.with_disable_lists(disable_lists);
+    }
+    if let Ok(max_page_size) = settings.get::<Option<usize>>("concurrency.max_page_size") {
+        app_config_builder = app_config_builder.with_max_page_size(max_page_size);
+    }
+
+    if let Ok(max_query_depth) = settings.get::<Option<usize>>("schema.max_query_depth") {
+        app_config_builder = app_config_builder.with_max_query_depth(max_query_depth);
+    }
+    if let Ok(max_query_complexity) = settings.get::<Option<usize>>("schema.max_query_complexity") {
+        app_config_builder = app_config_builder.with_max_query_complexity(max_query_complexity);
+    }
+    if let Ok(max_recursive_depth) = settings.get::<Option<usize>>("schema.max_recursive_depth") {
+        app_config_builder = app_config_builder.with_max_recursive_depth(max_recursive_depth);
+    }
+    if let Ok(max_directives_per_field) =
+        settings.get::<Option<usize>>("schema.max_directives_per_field")
+    {
+        app_config_builder =
+            app_config_builder.with_max_directives_per_field(max_directives_per_field);
+    }
+    if let Ok(disable_introspection) = settings.get::<bool>("schema.disable_introspection") {
+        app_config_builder = app_config_builder.with_disable_introspection(disable_introspection);
     }
 
     if let Ok(public_dir) = settings.get::<Option<PathBuf>>("public_dir") {
diff --git a/raphtory-graphql/src/config/auth_config.rs b/raphtory-graphql/src/config/auth_config.rs
index 166429ad1f..8a29300cad 100644
--- a/raphtory-graphql/src/config/auth_config.rs
+++ b/raphtory-graphql/src/config/auth_config.rs
@@ -1,16 +1,52 @@
 use base64::{prelude::BASE64_STANDARD, DecodeError, Engine};
-use jsonwebtoken::DecodingKey;
+use jsonwebtoken::{Algorithm, DecodingKey};
 use serde::{de, Deserialize, Deserializer, Serialize};
 use spki::SubjectPublicKeyInfoRef;
 use std::fmt::Debug;
 
-pub const DEFAULT_AUTH_ENABLED_FOR_READS: bool = true;
-pub const PUBLIC_KEY_DECODING_ERR_MSG: &str = "Could not successfully decode the public key. Make sure you use the standard alphabet with padding";
+pub const DEFAULT_REQUIRE_AUTH_FOR_READS: bool = true;
+pub const PUBLIC_KEY_DECODING_ERR_MSG: &str =
+    "Could not decode public key. Provide a base64-encoded DER (X.509 SPKI) public key \
+     for Ed25519 or RSA (2048-4096 bit).";
+
+/// Describes one family of asymmetric public-key algorithms that Raphtory can validate JWTs with.
+///
+/// To add support for a new algorithm family (e.g. EC/ECDSA), append one entry to
+/// [`SUPPORTED_ALGORITHMS`] — no other code needs to change.
+struct AlgorithmSpec {
+    /// X.509 SPKI algorithm OID string (e.g. `"1.3.101.112"` for Ed25519).
+    oid: &'static str,
+    /// Constructs the `DecodingKey` from the raw subject-public-key bytes extracted from the SPKI
+    /// structure (i.e. the inner key bytes, not the full DER-encoded SPKI wrapper).
+    make_key: fn(&[u8]) -> DecodingKey,
+    /// JWT algorithms accepted for this key family. All listed variants are allowed during
+    /// validation; the first entry is used as the `Validation` default.
+    algorithms: &'static [Algorithm],
+}
+
+/// Registry of supported public-key algorithm families.
+///
+/// # Adding a new family
+/// Append an [`AlgorithmSpec`] entry here. `TryFrom<String> for PublicKey` will pick it up
+/// automatically — no other changes required.
+const SUPPORTED_ALGORITHMS: &[AlgorithmSpec] = &[
+    AlgorithmSpec {
+        oid: "1.3.101.112", // id-EdDSA (Ed25519)
+        make_key: DecodingKey::from_ed_der,
+        algorithms: &[Algorithm::EdDSA],
+    },
+    AlgorithmSpec {
+        oid: "1.2.840.113549.1.1.1", // rsaEncryption (PKCS#1)
+        make_key: DecodingKey::from_rsa_der,
+        algorithms: &[Algorithm::RS256, Algorithm::RS384, Algorithm::RS512],
+    },
+];
 
 #[derive(Clone)]
 pub struct PublicKey {
     source: String,
     pub(crate) decoding_key: DecodingKey,
+    pub(crate) algorithms: Vec<Algorithm>,
 }
 
 impl PartialEq for PublicKey {
@@ -23,8 +59,10 @@ impl PartialEq for PublicKey {
 pub enum PublicKeyError {
     #[error(transparent)]
     Base64(#[from] DecodeError),
-    #[error("The provided key is not a a valid X.509 Subject Public Key Info ASN.1 structure")]
+    #[error("The provided key is not a valid X.509 Subject Public Key Info ASN.1 structure")]
     Spki,
+    #[error("Key algorithm is not supported; see SUPPORTED_ALGORITHMS for accepted OIDs")]
+    UnsupportedAlgorithm,
 }
 
 impl TryFrom<String> for PublicKey {
@@ -33,10 +71,16 @@ impl TryFrom<String> for PublicKey {
         let der = BASE64_STANDARD.decode(&value)?;
         let spki_ref =
             SubjectPublicKeyInfoRef::try_from(der.as_ref()).map_err(|_| PublicKeyError::Spki)?;
-        let decoding_key = DecodingKey::from_ed_der(spki_ref.subject_public_key.raw_bytes());
+        let oid = spki_ref.algorithm.oid.to_string();
+        let spec = SUPPORTED_ALGORITHMS
+            .iter()
+            .find(|s| s.oid == oid.as_str())
+            .ok_or(PublicKeyError::UnsupportedAlgorithm)?;
+        let raw = spki_ref.subject_public_key.raw_bytes();
         Ok(Self {
             source: value,
-            decoding_key,
+            decoding_key: (spec.make_key)(raw),
+            algorithms: spec.algorithms.to_vec(),
         })
     }
 }
@@ -69,14 +113,14 @@ impl Debug for PublicKey {
 #[derive(Debug, Deserialize, Clone, Serialize, PartialEq)]
 pub struct AuthConfig {
     pub public_key: Option<PublicKey>,
-    pub enabled_for_reads: bool,
+    pub require_auth_for_reads: bool,
 }
 
 impl Default for AuthConfig {
     fn default() -> Self {
         Self {
             public_key: None,
-            enabled_for_reads: DEFAULT_AUTH_ENABLED_FOR_READS,
+            require_auth_for_reads: DEFAULT_REQUIRE_AUTH_FOR_READS,
         }
     }
 }
diff --git a/raphtory-graphql/src/config/concurrency_config.rs b/raphtory-graphql/src/config/concurrency_config.rs
new file mode 100644
index 0000000000..5e7d9f754f
--- /dev/null
+++ b/raphtory-graphql/src/config/concurrency_config.rs
@@ -0,0 +1,40 @@
+use serde::{Deserialize, Serialize};
+
+pub const DEFAULT_EXCLUSIVE_WRITES: bool = false;
+pub const DEFAULT_DISABLE_BATCHING: bool = false;
+pub const DEFAULT_DISABLE_LISTS: bool = false;
+
+/// Controls how Raphtory schedules concurrent GraphQL work.
+#[derive(Debug, Default, Deserialize, PartialEq, Clone, Serialize)]
+pub struct ConcurrencyConfig {
+    /// Restricts how many expensive graph traversal queries can execute simultaneously.
+    /// Covers operations like connected components, edge traversals, and neighbour lookups
+    /// (outComponent, inComponent, edges, outEdges, inEdges, neighbours, outNeighbours,
+    /// inNeighbours). Once the limit is exceeded, queries are parked on a semaphore and
+    /// wait until a slot becomes available before executing. `None` means unlimited.
+    pub heavy_query_limit: Option<usize>,
+
+    /// Ensures only one ingestion/write operation runs at a time and blocks reads until
+    /// it completes.
+    pub exclusive_writes: bool,
+
+    /// When true, query batching (sending multiple queries in a single HTTP request) is
+    /// rejected outright. Batching can otherwise be used to circumvent per-request depth
+    /// and complexity limits.
+    pub disable_batching: bool,
+
+    /// Caps the number of queries accepted in a single batched HTTP request. Requests
+    /// whose batch exceeds this size are rejected. `None` means unlimited (subject to
+    /// `disable_batching`).
+    pub max_batch_size: Option<usize>,
+
+    /// When true, completely disables bulk list endpoints (e.g. `list` on a collection).
+    /// Essential for large graphs where unbounded list queries could return billions of
+    /// results and exhaust server resources. Clients should use `page` instead.
+    pub disable_lists: bool,
+
+    /// Maximum page size enforced on paged collection queries. Caps the `limit` argument
+    /// of `page` so clients can't circumvent `disable_lists` by requesting huge pages.
+    /// `None` means unlimited.
+    pub max_page_size: Option<usize>,
+}
diff --git a/raphtory-graphql/src/config/mod.rs b/raphtory-graphql/src/config/mod.rs
index e0ae764243..9ef7311dec 100644
--- a/raphtory-graphql/src/config/mod.rs
+++ b/raphtory-graphql/src/config/mod.rs
@@ -1,10 +1,12 @@
 pub mod app_config;
 pub mod auth_config;
 pub mod cache_config;
+pub mod concurrency_config;
 #[cfg(feature = "search")]
 pub mod index_config;
 pub mod log_config;
 pub mod otlp_config;
+pub mod schema_config;
 
 #[cfg(test)]
 mod tests {
diff --git a/raphtory-graphql/src/config/schema_config.rs b/raphtory-graphql/src/config/schema_config.rs
new file mode 100644
index 0000000000..b327617bb6
--- /dev/null
+++ b/raphtory-graphql/src/config/schema_config.rs
@@ -0,0 +1,30 @@
+use serde::{Deserialize, Serialize};
+
+pub const DEFAULT_DISABLE_INTROSPECTION: bool = false;
+
+/// Controls GraphQL schema-level protections applied when the server builds its schema.
+#[derive(Debug, Default, Deserialize, PartialEq, Clone, Serialize)]
+pub struct SchemaConfig {
+    /// Limits how deeply nested a query can be. For example, a query like
+    /// graph → nodes → page → edges → page → destination → edges → page → destination
+    /// would have a depth of 9. `None` means unlimited.
+    pub max_query_depth: Option<usize>,
+
+    /// Limits the total estimated cost of a query based on the number of fields selected.
+    /// Blocks queries that try to fetch too much data in one request. `None` means unlimited.
+    pub max_query_complexity: Option<usize>,
+
+    /// Internal safety limit to prevent stack overflows from pathologically structured
+    /// queries. `None` falls back to the async-graphql default of 32.
+    pub max_recursive_depth: Option<usize>,
+
+    /// Limits the number of GraphQL directives on any single field. Directives are
+    /// annotations prefixed with @ that modify how a field is executed (e.g. @skip,
+    /// @include, @deprecated). This prevents directive-based abuse. `None` means unlimited.
+    pub max_directives_per_field: Option<usize>,
+
+    /// When true, schema introspection is fully disabled, preventing clients from
+    /// discovering the API's structure and available fields. Recommended for production
+    /// to reduce the attack surface.
+    pub disable_introspection: bool,
+}
diff --git a/raphtory-graphql/src/data.rs b/raphtory-graphql/src/data.rs
index 7fbad3cc53..ce4434be96 100644
--- a/raphtory-graphql/src/data.rs
+++ b/raphtory-graphql/src/data.rs
@@ -1,68 +1,178 @@
 use crate::{
+    auth_policy::AuthorizationPolicy,
     config::app_config::AppConfig,
     graph::GraphWithVectors,
     model::blocking_io,
-    paths::{valid_path, ExistingGraphFolder, ValidGraphFolder},
+    paths::{
+        mark_dirty, ExistingGraphFolder, InternalPathValidationError, PathValidationError,
+        ValidGraphPaths, ValidWriteableGraphFolder,
+    },
+    rayon::blocking_compute,
+    GQLError,
 };
-use itertools::Itertools;
+use futures_util::FutureExt;
 use moka::future::Cache;
 use raphtory::{
-    db::api::view::MaterializedGraph,
-    errors::{GraphError, GraphResult, InvalidPathReason},
-    prelude::CacheOps,
+    db::api::{storage::storage::Config, view::MaterializedGraph},
+    errors::GraphError,
+    serialise::GraphPaths,
     vectors::{
-        cache::CachedEmbeddingModel, storage::LazyDiskVectorCache, template::DocumentTemplate,
-        vectorisable::Vectorisable, vectorised_graph::VectorisedGraph,
+        cache::{CachedEmbeddingModel, VectorCache},
+        storage::LazyDiskVectorCache,
+        template::DocumentTemplate,
+        vectorisable::Vectorisable,
+        vectorised_graph::VectorisedGraph,
     },
 };
 use std::{
+    collections::HashMap,
+    fs, io,
+    io::{Read, Seek},
+    ops::{Deref, DerefMut},
     path::{Path, PathBuf},
     sync::Arc,
 };
-use tokio::fs;
 use tracing::{error, warn};
 use walkdir::WalkDir;
 
+pub const DIRTY_PATH: &'static str = ".dirty";
+
+#[derive(thiserror::Error, Debug)]
+pub enum MutationErrorInner {
+    #[error(transparent)]
+    GraphError(#[from] GraphError),
+    #[error(transparent)]
+    IO(#[from] io::Error),
+    #[error(transparent)]
+    InvalidInternal(#[from] InternalPathValidationError),
+}
+
+#[derive(thiserror::Error, Debug)]
+pub enum InsertionError {
+    #[error("Failed to insert graph {graph}: {error}")]
+    Insertion {
+        graph: String,
+        error: MutationErrorInner,
+    },
+    #[error(transparent)]
+    PathValidation(#[from] PathValidationError),
+    #[error("Failed to insert graph {graph}: {error}")]
+    GraphError { graph: String, error: GraphError },
+}
+
+impl InsertionError {
+    pub fn from_inner(graph: &str, error: MutationErrorInner) -> Self {
+        InsertionError::Insertion {
+            graph: graph.to_string(),
+            error,
+        }
+    }
+
+    pub fn from_graph_err(graph: &str, error: GraphError) -> Self {
+        InsertionError::GraphError {
+            graph: graph.to_string(),
+            error,
+        }
+    }
+}
+
+#[derive(thiserror::Error, Debug)]
+pub enum DeletionError {
+    #[error("Failed to delete graph {graph}: {error}")]
+    Insertion {
+        graph: String,
+        error: MutationErrorInner,
+    },
+    #[error(transparent)]
+    PathValidation(#[from] PathValidationError),
+}
+
+#[derive(thiserror::Error, Debug)]
+pub enum MoveError {
+    #[error("Failed to move graph: {0}")]
+    Insertion(#[from] InsertionError),
+    #[error("Failed to move graph: {0}")]
+    Deletion(#[from] DeletionError),
+}
+
+impl DeletionError {
+    fn from_inner(graph: &str, error: MutationErrorInner) -> Self {
+        DeletionError::Insertion {
+            graph: graph.to_string(),
+            error,
+        }
+    }
+}
+
+/// Get relative path as String joined with `"/"` for use with the validation methods.
+/// The path is not validated here!
 pub(crate) fn get_relative_path(
-    work_dir: PathBuf,
+    work_dir: &Path,
     path: &Path,
-    namespace: bool,
-) -> Result<String, InvalidPathReason> {
-    let path_buf = path.strip_prefix(work_dir.clone())?.to_path_buf();
-    let components = path_buf
-        .components()
-        .into_iter()
-        .map(|c| {
-            c.as_os_str()
-                .to_str()
-                .ok_or(InvalidPathReason::NonUTFCharacters)
-        })
-        .collect::<Result<Vec<_>, _>>()?;
-    let path_str = components.into_iter().join("/");
-    valid_path(work_dir, &path_str, namespace)?;
+) -> Result<String, InternalPathValidationError> {
+    let relative = path.strip_prefix(work_dir)?;
+    let mut path_str = String::new();
+    let mut components = relative.components().map(|component| {
+        component
+            .as_os_str()
+            .to_str()
+            .ok_or(InternalPathValidationError::NonUTFCharacters)
+    });
+    if let Some(first) = components.next() {
+        path_str.push_str(first?);
+    }
+    for component in components {
+        path_str.push('/');
+        path_str.push_str(component?);
+    }
     Ok(path_str)
 }
 
+/// Inner struct with a drop implementation that cleans up the graphs
+pub struct DataInner {
+    pub(crate) work_dir: PathBuf,
+    pub(crate) cache: Cache<String, GraphWithVectors>,
+    pub(crate) vector_cache: LazyDiskVectorCache,
+    pub(crate) graph_conf: Config,
+    pub(crate) auth_policy: Option<Arc<dyn AuthorizationPolicy>>,
+}
+
+/// Outer data struct that wraps the inner data to make sure it is only dropped once
 #[derive(Clone)]
 pub struct Data {
-    pub(crate) work_dir: PathBuf, // TODO: move this to config?
-    pub(crate) cache: Cache<PathBuf, GraphWithVectors>,
-    pub(crate) create_index: bool, // TODO: move this to config?
-    pub(crate) vector_cache: LazyDiskVectorCache,
+    inner: Arc<DataInner>,
+    pub(crate) create_index: bool,
+}
+
+impl Deref for Data {
+    type Target = DataInner;
+
+    fn deref(&self) -> &Self::Target {
+        self.inner.deref()
+    }
 }
 
 impl Data {
-    pub fn new(work_dir: &Path, configs: &AppConfig) -> Self {
+    pub fn new(work_dir: &Path, configs: &AppConfig, graph_conf: Config) -> Self {
         let cache_configs = &configs.cache;
 
-        let cache = Cache::<PathBuf, GraphWithVectors>::builder()
+        let cache = Cache::<String, GraphWithVectors>::builder()
             .max_capacity(cache_configs.capacity)
             .time_to_idle(std::time::Duration::from_secs(cache_configs.tti_seconds))
-            .eviction_listener(|_, graph, _| {
-                graph
-                    .write_updates()
-                    .unwrap_or_else(|err| error!("Write on eviction failed: {err:?}"))
-                // FIXME: don't have currently a way to know which embedding updates are pending
+            .async_eviction_listener(|_, graph, cause| {
+                // The eviction listener gets called any time a graph is removed from the cache,
+                // not just when it is evicted. Only serialize on evictions.
+                async move {
+                    if !cause.was_evicted() {
+                        return;
+                    }
+                    if let Err(e) =
+                        blocking_compute(move || graph.folder.replace_graph_data(graph.graph)).await
+                    {
+                        error!("Error encoding graph to disk on eviction: {e}");
+                    }
+                }
+                .boxed()
             })
             .build();
 
@@ -74,62 +184,119 @@ impl Data {
         // TODO: make vector feature optional?
 
         Self {
-            work_dir: work_dir.to_path_buf(),
-            cache,
+            inner: Arc::new(DataInner {
+                work_dir: work_dir.to_path_buf(),
+                cache,
+                vector_cache: LazyDiskVectorCache::new(work_dir.join(".vector-cache")),
+                graph_conf,
+                auth_policy: None,
+            }),
             create_index,
-            vector_cache: LazyDiskVectorCache::new(work_dir.join(".vector-cache")),
         }
     }
 
-    pub async fn get_graph(
+    pub(crate) fn set_auth_policy(&mut self, policy: Arc<dyn AuthorizationPolicy>) {
+        Arc::get_mut(&mut self.inner)
+            .expect("Data is not uniquely owned when setting auth_policy")
+            .auth_policy = Some(policy);
+    }
+
+    async fn invalidate(&self, path: &str) {
+        self.cache.invalidate(path).await;
+        self.cache.run_pending_tasks().await; // make sure the item is actually dropped
+    }
+
+    pub fn validate_path_for_insert(
         &self,
         path: &str,
-    ) -> Result<(GraphWithVectors, ExistingGraphFolder), Arc<GraphError>> {
-        let graph_folder = ExistingGraphFolder::try_from(self.work_dir.clone(), path)?;
-        let graph_folder_clone = graph_folder.clone();
+        overwrite: bool,
+    ) -> Result<ValidWriteableGraphFolder, PathValidationError> {
+        if overwrite {
+            ValidWriteableGraphFolder::try_existing_or_new(self.work_dir.clone(), path)
+        } else {
+            ValidWriteableGraphFolder::try_new(self.work_dir.clone(), path)
+        }
+    }
+
+    pub async fn get_graph(&self, path: &str) -> Result<GraphWithVectors, Arc<GQLError>> {
         self.cache
-            .try_get_with(path.into(), self.read_graph_from_folder(graph_folder_clone))
+            .try_get_with(path.into(), self.read_graph_from_disk(path))
             .await
-            .map(|graph| (graph, graph_folder))
+    }
+
+    pub async fn get_cached_graph(&self, path: &str) -> Option<GraphWithVectors> {
+        self.cache.get(path).await
+    }
+
+    pub fn has_graph(&self, path: &str) -> bool {
+        self.cache.contains_key(path)
+            || ExistingGraphFolder::try_from(self.work_dir.clone(), path).is_ok()
     }
 
     pub async fn insert_graph(
         &self,
-        path: &str,
+        writeable_folder: ValidWriteableGraphFolder,
         graph: MaterializedGraph,
-    ) -> Result<(), GraphError> {
-        // TODO: replace ValidGraphFolder with ValidNonExistingGraphFolder !!!!!!!!!
-        // or even a NewGraphFolder, so that we try to create the graph file and if that is sucessful
-        // we can write to it and its guaranteed to me atomic
-        let folder = ValidGraphFolder::try_from(self.work_dir.clone(), path)?;
-        match ExistingGraphFolder::try_from(self.work_dir.clone(), path) {
-            Ok(_) => Err(GraphError::GraphNameAlreadyExists(folder.to_error_path())),
-            Err(_) => {
-                fs::create_dir_all(folder.get_base_path()).await?;
-                let folder_clone = folder.clone();
-                let graph_clone = graph.clone();
-                blocking_io(move || graph_clone.cache(folder_clone)).await?;
-                let graph = GraphWithVectors::new(graph, None);
-                graph
-                    .folder
-                    .get_or_try_init(|| Ok::<_, GraphError>(folder.into()))?;
-                self.cache.insert(path.into(), graph).await;
-                Ok(())
-            }
-        }
+    ) -> Result<(), InsertionError> {
+        self.invalidate(writeable_folder.local_path()).await;
+        let config = self.graph_conf.clone();
+        let graph = blocking_compute(move || {
+            writeable_folder.write_graph_data(graph.clone(), config)?;
+            let folder = writeable_folder.finish()?;
+            let graph = GraphWithVectors::new(graph, None, folder.as_existing()?);
+            Ok::<_, InsertionError>(graph)
+        })
+        .await?;
+        self.cache
+            .insert(graph.folder.local_path().into(), graph)
+            .await;
+        Ok(())
+    }
+
+    /// Insert a graph serialized from a graph folder.
+    pub async fn insert_graph_as_bytes<R: Read + Seek + Send + 'static>(
+        &self,
+        folder: ValidWriteableGraphFolder,
+        bytes: R,
+    ) -> Result<(), InsertionError> {
+        self.invalidate(folder.local_path()).await;
+        let conf = self.graph_conf.clone();
+        blocking_io(move || {
+            folder.write_graph_bytes(bytes, conf)?;
+            folder.finish()
+        })
+        .await?;
+        Ok(())
     }
 
-    pub async fn delete_graph(&self, path: &str) -> Result<(), GraphError> {
+    async fn delete_graph_inner(
+        &self,
+        graph_folder: ExistingGraphFolder,
+    ) -> Result<(), MutationErrorInner> {
+        let dirty_file = mark_dirty(graph_folder.root())?;
+        self.invalidate(graph_folder.local_path()).await;
+        blocking_io(move || {
+            fs::remove_dir_all(graph_folder.root())?;
+            fs::remove_file(dirty_file)?;
+            Ok::<_, MutationErrorInner>(())
+        })
+        .await?;
+        Ok(())
+    }
+
+    pub async fn delete_graph(&self, path: &str) -> Result<(), DeletionError> {
         let graph_folder = ExistingGraphFolder::try_from(self.work_dir.clone(), path)?;
-        fs::remove_dir_all(graph_folder.get_base_path()).await?;
-        self.cache.remove(&PathBuf::from(path)).await;
+        self.delete_graph_inner(graph_folder)
+            .await
+            .map_err(|err| DeletionError::from_inner(path, err))?;
+        self.cache.remove(path).await;
         Ok(())
     }
 
     async fn vectorise_with_template(
         &self,
         graph: MaterializedGraph,
-        folder: &ValidGraphFolder,
+        folder: &impl ValidGraphPaths,
         template: &DocumentTemplate,
         model: CachedEmbeddingModel,
     ) -> Option<VectorisedGraph<MaterializedGraph>> {
@@ -137,14 +304,14 @@ impl Data {
             .vectorise(
                 model,
                 template.clone(),
-                Some(&folder.get_vectors_path()),
+                Some(&folder.graph_folder().vectors_path().ok()?),
                 true, // verbose
             )
             .await;
         match vectors {
             Ok(vectors) => Some(vectors),
             Err(error) => {
-                let name = folder.get_original_path_str();
+                let name = folder.local_path();
                 warn!("An error occurred when trying to vectorise graph {name}: {error}");
                 None
             }
@@ -156,160 +323,92 @@ impl Data {
         folder: &ExistingGraphFolder,
         template: &DocumentTemplate,
         model: CachedEmbeddingModel,
-    ) -> GraphResult<()> {
-        let graph = self.read_graph_from_folder(folder.clone()).await?.graph;
-        self.vectorise_with_template(graph, folder, template, model)
-            .await;
-        self.cache
-            .remove(&folder.get_original_path().to_path_buf())
+    ) -> Result<(), GQLError> {
+        let graph = match self.get_cached_graph(folder.local_path()).await {
+            None => self.read_graph_from_disk_inner(folder.clone()).await?,
+            Some(graph) => graph,
+        };
+        self.vectorise_with_template(graph.graph, folder, template, model)
             .await;
+        self.cache.remove(folder.local_path()).await;
         Ok(())
     }
 
-    // TODO: return iter
-    pub fn get_all_graph_folders(&self) -> Vec<ExistingGraphFolder> {
+    pub fn get_all_graph_folders(&self) -> impl Iterator<Item = ExistingGraphFolder> {
         let base_path = self.work_dir.clone();
         WalkDir::new(&self.work_dir)
             .into_iter()
-            .filter_map(|e| {
+            .filter_map(move |e| {
                 let entry = e.ok()?;
                 let path = entry.path();
-                let relative = get_relative_path(base_path.clone(), path, false).ok()?;
+                let relative = get_relative_path(&base_path, path).ok()?;
                 let folder = ExistingGraphFolder::try_from(base_path.clone(), &relative).ok()?;
                 Some(folder)
             })
-            .collect()
     }
 
-    async fn read_graph_from_folder(
+    async fn read_graph_from_disk_inner(
         &self,
         folder: ExistingGraphFolder,
     ) -> Result<GraphWithVectors, GraphError> {
-        GraphWithVectors::read_from_folder(&folder, &self.vector_cache, self.create_index).await
-        // FIXME: I need some blocking_io inside of GraphWithVectors::read_from_folder
+        let create_index = self.create_index;
+        let config = self.graph_conf.clone();
+        let cache = self.vector_cache.clone();
+        GraphWithVectors::read_from_folder(&folder, &cache, create_index, config).await
     }
-}
 
-#[cfg(test)]
-pub(crate) mod data_tests {
-    use super::ValidGraphFolder;
-    use crate::{
-        config::app_config::{AppConfig, AppConfigBuilder},
-        data::Data,
-    };
-    use itertools::Itertools;
-    use raphtory::{db::api::view::MaterializedGraph, errors::GraphError, prelude::*};
-    use std::{collections::HashMap, fs, fs::File, io, path::Path, time::Duration};
-    use tokio::time::sleep;
+    async fn read_graph_from_disk(&self, path: &str) -> Result<GraphWithVectors, GQLError> {
+        let folder = ExistingGraphFolder::try_from(self.work_dir.clone(), path)?;
+        Ok(self.read_graph_from_disk_inner(folder).await?)
+    }
+}
 
-    #[cfg(feature = "storage")]
-    use raphtory_storage::{core_ops::CoreGraphOps, graph::graph::GraphStorage};
-
-    #[cfg(feature = "storage")]
-    fn copy_dir_recursive(source_dir: &Path, target_dir: &Path) -> Result<(), GraphError> {
-        fs::create_dir_all(target_dir)?;
-        for entry in fs::read_dir(source_dir)? {
-            let entry = entry?;
-            let entry_path = entry.path();
-            let target_path = target_dir.join(entry.file_name());
-
-            if entry_path.is_dir() {
-                copy_dir_recursive(&entry_path, &target_path)?;
-            } else {
-                fs::copy(&entry_path, &target_path)?;
+impl Drop for DataInner {
+    fn drop(&mut self) {
+        // On drop, serialize graphs that don't have underlying storage.
+        for (_, graph) in self.cache.iter() {
+            if graph.is_dirty() {
+                if let Err(e) = graph.folder.replace_graph_data(graph.graph) {
+                    error!("Error encoding graph to disk on drop: {e}");
+                }
             }
         }
-        Ok(())
     }
+}
 
-    // This function creates files that mimic disk graph for tests
-    fn create_ipc_files_in_dir(dir_path: &Path) -> io::Result<()> {
-        if !dir_path.exists() {
-            fs::create_dir_all(dir_path)?;
-        }
-
-        let file_paths = ["file1.ipc", "file2.txt", "file3.ipc"];
-
-        for &file_name in &file_paths {
-            let file_path = dir_path.join(file_name);
-            File::create(file_path)?;
-        }
-
-        Ok(())
-    }
+#[cfg(test)]
+pub(crate) mod data_tests {
+    use super::InsertionError;
+    use crate::{config::app_config::AppConfigBuilder, data::Data};
+    use itertools::Itertools;
+    use raphtory::{
+        db::api::view::{internal::InternalStorageOps, MaterializedGraph},
+        prelude::*,
+        serialise::GraphPaths,
+    };
+    use std::{collections::HashMap, fs, path::Path, time::Duration};
+    use tokio::time::sleep;
 
     fn create_graph_folder(path: &Path) {
+        // Use empty graph to create folder structure
         fs::create_dir_all(path).unwrap();
-        File::create(path.join(".raph")).unwrap();
-        File::create(path.join("graph")).unwrap();
+        let graph = Graph::new();
+        graph.encode(path).unwrap();
     }
 
     pub(crate) async fn save_graphs_to_work_dir(
-        work_dir: &Path,
+        data: &Data,
         graphs: &HashMap<String, MaterializedGraph>,
-    ) -> Result<(), GraphError> {
+    ) -> Result<(), InsertionError> {
         for (name, graph) in graphs.into_iter() {
-            let data = Data::new(work_dir, &AppConfig::default());
-            let folder = ValidGraphFolder::try_from(data.work_dir, name)?;
-
-            #[cfg(feature = "storage")]
-            if let GraphStorage::Disk(dg) = graph.core_graph() {
-                let disk_graph_path = dg.graph_dir();
-                copy_dir_recursive(disk_graph_path, &folder.get_graph_path())?;
-                File::create(folder.get_meta_path())?;
-            } else {
-                graph.encode(folder)?;
-            }
-
-            #[cfg(not(feature = "storage"))]
-            graph.encode(folder)?;
+            let folder = data.validate_path_for_insert(name, true)?;
+            data.insert_graph(folder, graph.clone()).await?;
         }
         Ok(())
     }
 
-    #[tokio::test]
-    #[cfg(feature = "storage")]
-    async fn test_get_disk_graph_from_path() {
-        let tmp_graph_dir = tempfile::tempdir().unwrap();
-
-        let graph = Graph::new();
-        graph
-            .add_edge(0, 1, 2, [("name", "test_e1")], None)
-            .unwrap();
-        graph
-            .add_edge(0, 1, 3, [("name", "test_e2")], None)
-            .unwrap();
-
-        let base_path = tmp_graph_dir.path().to_owned();
-        let graph_path = base_path.join("test_dg");
-        fs::create_dir(&graph_path).unwrap();
-        File::create(graph_path.join(".raph")).unwrap();
-        let _ = DiskGraphStorage::from_graph(&graph, &graph_path.join("graph")).unwrap();
-
-        let data = Data::new(&base_path, &Default::default());
-        let res = data.get_graph("test_dg").await.unwrap().0;
-        assert_eq!(res.graph.into_events().unwrap().count_edges(), 2);
-
-        // Dir path doesn't exists
-        let res = data.get_graph("test_dg1").await;
-        assert!(res.is_err());
-        if let Err(err) = res {
-            assert!(err.to_string().contains("Graph not found"));
-        }
-
-        // Dir path exists but is not a disk graph path
-        // let tmp_graph_dir = tempfile::tempdir().unwrap();
-        // let res = read_graph_from_path(base_path, "");
-        let res = data.get_graph("").await;
-        assert!(res.is_err());
-        if let Err(err) = res {
-            assert!(err.to_string().contains("Graph not found"));
-        }
-    }
-
     #[tokio::test]
     async fn test_save_graphs_to_work_dir() {
-        let tmp_graph_dir = tempfile::tempdir().unwrap();
         let tmp_work_dir = tempfile::tempdir().unwrap();
 
         let graph = Graph::new();
@@ -321,26 +420,14 @@ pub(crate) mod data_tests {
             .add_edge(0, 1, 3, [("name", "test_e2")], None)
             .unwrap();
 
-        #[cfg(feature = "storage")]
-        let graph2: MaterializedGraph = graph
-            .persist_as_disk_graph(tmp_graph_dir.path())
-            .unwrap()
-            .into();
-
         let graph: MaterializedGraph = graph.into();
 
         let mut graphs = HashMap::new();
 
         graphs.insert("test_g".to_string(), graph);
+        let data = Data::new(tmp_work_dir.path(), &Default::default(), Default::default());
 
-        #[cfg(feature = "storage")]
-        graphs.insert("test_dg".to_string(), graph2);
-
-        save_graphs_to_work_dir(tmp_work_dir.path(), &graphs)
-            .await
-            .unwrap();
-
-        let data = Data::new(tmp_work_dir.path(), &Default::default());
+        save_graphs_to_work_dir(&data, &graphs).await.unwrap();
 
         for graph in graphs.keys() {
             assert!(data.get_graph(graph).await.is_ok(), "could not get {graph}")
@@ -367,23 +454,23 @@ pub(crate) mod data_tests {
             .with_cache_tti_seconds(2)
             .build();
 
-        let data = Data::new(tmp_work_dir.path(), &configs);
+        let data = Data::new(tmp_work_dir.path(), &configs, Default::default());
 
-        assert!(!data.cache.contains_key(Path::new("test_g")));
-        assert!(!data.cache.contains_key(Path::new("test_g2")));
+        assert!(!data.cache.contains_key("test_g"));
+        assert!(!data.cache.contains_key("test_g2"));
 
         // Test size based eviction
         data.get_graph("test_g2").await.unwrap();
-        assert!(data.cache.contains_key(Path::new("test_g2")));
-        assert!(!data.cache.contains_key(Path::new("test_g")));
+        assert!(data.cache.contains_key("test_g2"));
+        assert!(!data.cache.contains_key("test_g"));
 
         data.get_graph("test_g").await.unwrap(); // wait for any eviction
         data.cache.run_pending_tasks().await;
         assert_eq!(data.cache.iter().count(), 1);
 
         sleep(Duration::from_secs(3)).await;
-        assert!(!data.cache.contains_key(Path::new("test_g")));
-        assert!(!data.cache.contains_key(Path::new("test_g2")));
+        assert!(!data.cache.contains_key("test_g"));
+        assert!(!data.cache.contains_key("test_g2"));
         // FIXME: this test is not doing anything because calling cache.contains_key() runs
         // any pending evictions. To actually test it we need this assertion:
         //   assert_eq!(data.cache.entry_count(), 0);
@@ -398,6 +485,7 @@ pub(crate) mod data_tests {
     async fn test_get_graph_paths() {
         let temp_dir = tempfile::tempdir().unwrap();
         let work_dir = temp_dir.path();
+
         let g0_path = work_dir.join("g0");
         let g1_path = work_dir.join("g1");
         let g2_path = work_dir.join("shivam/investigations/2024-12-22/g2");
@@ -411,14 +499,13 @@ pub(crate) mod data_tests {
         create_graph_folder(&g1_path);
         create_graph_folder(&g2_path);
         create_graph_folder(&g3_path);
+        create_graph_folder(&g4_path);
         create_graph_folder(&g7_path);
 
-        fs::create_dir_all(&g4_path.join("graph")).unwrap();
-        File::create(g4_path.join(".raph")).unwrap();
-        create_ipc_files_in_dir(&g4_path.join("graph")).unwrap();
-
+        // Empty, non-graph folder
         fs::create_dir_all(&g5_path).unwrap();
 
+        // Simulate non-graph folder with random files
         fs::create_dir_all(&g6_path).unwrap();
         fs::write(g6_path.join("random-file"), "some-random-content").unwrap();
 
@@ -427,12 +514,12 @@ pub(crate) mod data_tests {
             .with_cache_tti_seconds(2)
             .build();
 
-        let data = Data::new(work_dir, &configs);
+        let data = Data::new(work_dir, &configs, Default::default());
 
         let paths = data
             .get_all_graph_folders()
             .into_iter()
-            .map(|folder| folder.get_base_path().to_path_buf())
+            .map(|folder| folder.0.root().to_path_buf())
             .collect_vec();
 
         assert_eq!(paths.len(), 5);
@@ -441,14 +528,187 @@ pub(crate) mod data_tests {
         assert!(paths.contains(&g2_path));
         assert!(paths.contains(&g3_path));
         assert!(paths.contains(&g4_path));
-        assert!(!paths.contains(&g5_path)); // Empty dir is ignored
+        assert!(!paths.contains(&g5_path)); // Empty folder is ignored
+        assert!(!paths.contains(&g6_path)); // Non-graph folder is ignored
         assert!(!paths.contains(&g7_path)); // Hidden path is ignored
 
         assert!(data
             .get_graph("shivam/investigations/2024-12-22/g2")
             .await
             .is_ok());
+
         assert!(data.get_graph("some/random/path").await.is_err());
         assert!(data.get_graph(".graph").await.is_err());
     }
+
+    #[tokio::test]
+    async fn test_drop_skips_write_when_graph_is_not_dirty() {
+        let tmp_work_dir = tempfile::tempdir().unwrap();
+
+        // Create two graphs and save them to disk
+        let graph1 = Graph::new();
+        graph1
+            .add_edge(0, 1, 2, [("name", "test_e1")], None)
+            .unwrap();
+        graph1
+            .add_edge(0, 1, 3, [("name", "test_e2")], None)
+            .unwrap();
+
+        let graph2 = Graph::new();
+        graph2
+            .add_edge(0, 2, 3, [("name", "test_e3")], None)
+            .unwrap();
+        graph2
+            .add_edge(0, 2, 4, [("name", "test_e4")], None)
+            .unwrap();
+
+        let graph1_path = tmp_work_dir.path().join("test_graph1");
+        let graph2_path = tmp_work_dir.path().join("test_graph2");
+        graph1.encode(&graph1_path).unwrap();
+        graph2.encode(&graph2_path).unwrap();
+
+        // Record modification times before any operations
+        let graph1_metadata = fs::metadata(&graph1_path).unwrap();
+        let graph2_metadata = fs::metadata(&graph2_path).unwrap();
+        let graph1_original_time = graph1_metadata.modified().unwrap();
+        let graph2_original_time = graph2_metadata.modified().unwrap();
+
+        let configs = AppConfigBuilder::new()
+            .with_cache_capacity(10)
+            .with_cache_tti_seconds(300)
+            .build();
+
+        let data = Data::new(tmp_work_dir.path(), &configs, Default::default());
+
+        let loaded_graph1 = data.get_graph("test_graph1").await.unwrap();
+        let loaded_graph2 = data.get_graph("test_graph2").await.unwrap();
+
+        // TODO: This test doesn't work with disk storage right now, make sure modification dates actually update correctly!
+        if loaded_graph1.graph.disk_storage_path().is_some() {
+            assert!(
+                !loaded_graph1.is_dirty(),
+                "Graph1 should not be dirty when loaded from disk"
+            );
+            assert!(
+                !loaded_graph2.is_dirty(),
+                "Graph2 should not be dirty when loaded from disk"
+            );
+
+            // Modify only graph1 to make it dirty
+            loaded_graph1.set_dirty(true);
+            assert!(
+                loaded_graph1.is_dirty(),
+                "Graph1 should be dirty after modification"
+            );
+
+            // Drop the Data instance - this should trigger serialization
+            drop(data);
+
+            // Check modification times after drop
+            let graph1_metadata_after = fs::metadata(&graph1_path).unwrap();
+            let graph2_metadata_after = fs::metadata(&graph2_path).unwrap();
+            let graph1_modified_time = graph1_metadata_after.modified().unwrap();
+            let graph2_modified_time = graph2_metadata_after.modified().unwrap();
+
+            // Graph1 (dirty) modification time should be different
+            assert_ne!(
+                graph1_original_time, graph1_modified_time,
+                "Graph1 (dirty) should have been written to disk on drop"
+            );
+
+            // Graph2 (not dirty) modification time should be the same
+            assert_eq!(
+                graph2_original_time, graph2_modified_time,
+                "Graph2 (not dirty) should not have been written to disk on drop"
+            );
+        }
+    }
+
+    #[tokio::test]
+    async fn test_eviction_skips_write_when_graph_is_not_dirty() {
+        let tmp_work_dir = tempfile::tempdir().unwrap();
+
+        // Create two graphs and save them to disk
+        let graph1 = Graph::new();
+        graph1
+            .add_edge(0, 1, 2, [("name", "test_e1")], None)
+            .unwrap();
+        graph1
+            .add_edge(0, 1, 3, [("name", "test_e2")], None)
+            .unwrap();
+
+        let graph2 = Graph::new();
+        graph2
+            .add_edge(0, 2, 3, [("name", "test_e3")], None)
+            .unwrap();
+        graph2
+            .add_edge(0, 2, 4, [("name", "test_e4")], None)
+            .unwrap();
+
+        let graph1_path = tmp_work_dir.path().join("test_graph1");
+        let graph2_path = tmp_work_dir.path().join("test_graph2");
+        graph1.encode(&graph1_path).unwrap();
+        graph2.encode(&graph2_path).unwrap();
+
+        // Record modification times before any operations
+        let graph1_metadata = fs::metadata(&graph1_path).unwrap();
+        let graph2_metadata = fs::metadata(&graph2_path).unwrap();
+        let graph1_original_time = graph1_metadata.modified().unwrap();
+        let graph2_original_time = graph2_metadata.modified().unwrap();
+
+        // Create cache with time to idle 3 seconds to force eviction
+        let configs = AppConfigBuilder::new()
+            .with_cache_capacity(10)
+            .with_cache_tti_seconds(3)
+            .build();
+
+        let data = Data::new(tmp_work_dir.path(), &configs, Default::default());
+
+        // Load first graph
+        let loaded_graph1 = data.get_graph("test_graph1").await.unwrap();
+        assert!(
+            !loaded_graph1.is_dirty(),
+            "Graph1 should not be dirty when loaded from disk"
+        );
+
+        // Modify graph1 to make it dirty
+        loaded_graph1.set_dirty(true);
+        assert!(
+            loaded_graph1.is_dirty(),
+            "Graph1 should be dirty after modification"
+        );
+
+        // Load second graph
+        println!("Loading second graph");
+        let loaded_graph2 = data.get_graph("test_graph2").await.unwrap();
+        assert!(
+            !loaded_graph2.is_dirty(),
+            "Graph2 should not be dirty when loaded from disk"
+        );
+
+        // Sleep to trigger eviction
+        sleep(Duration::from_secs(3)).await;
+        data.cache.run_pending_tasks().await;
+
+        // TODO: This test doesn't work with disk storage right now, make sure modification dates actually update correctly!
+        if loaded_graph1.graph.disk_storage_path().is_some() {
+            // Check modification times after eviction
+            let graph1_metadata_after = fs::metadata(&graph1_path).unwrap();
+            let graph2_metadata_after = fs::metadata(&graph2_path).unwrap();
+            let graph1_modified_time = graph1_metadata_after.modified().unwrap();
+            let graph2_modified_time = graph2_metadata_after.modified().unwrap();
+
+            // Graph1 (dirty) modification time should be different
+            assert_ne!(
+                graph1_original_time, graph1_modified_time,
+                "Graph1 (dirty) should have been written to disk on eviction"
+            );
+
+            // Graph2 (not dirty) modification time should be the same
+            assert_eq!(
+                graph2_original_time, graph2_modified_time,
+                "Graph2 (not dirty) should not have been written to disk on eviction"
+            );
+        }
+    }
 }
diff --git a/raphtory-graphql/src/graph.rs b/raphtory-graphql/src/graph.rs
index fb47251b53..663adbcd23 100644
--- a/raphtory-graphql/src/graph.rs
+++ b/raphtory-graphql/src/graph.rs
@@ -1,51 +1,67 @@
-use crate::paths::ExistingGraphFolder;
-use once_cell::sync::OnceCell;
+use crate::{
+    paths::{ExistingGraphFolder, ValidGraphPaths},
+    rayon::blocking_compute,
+};
 use raphtory::{
     core::entities::nodes::node_ref::AsNodeRef,
     db::{
-        api::view::{
-            internal::{
-                InheritEdgeHistoryFilter, InheritNodeHistoryFilter, InheritStorageOps, Static,
+        api::{
+            storage::storage::Config,
+            view::{
+                internal::{
+                    InheritEdgeHistoryFilter, InheritNodeHistoryFilter, InheritStorageOps, Static,
+                },
+                Base, InheritViewOps, MaterializedGraph,
             },
-            Base, InheritViewOps, MaterializedGraph,
         },
         graph::{edge::EdgeView, node::NodeView},
     },
     errors::{GraphError, GraphResult},
-    prelude::{CacheOps, EdgeViewOps, IndexMutationOps},
-    serialise::GraphFolder,
-    storage::core_ops::CoreGraphOps,
-    vectors::{
-        cache::VectorCache, storage::LazyDiskVectorCache, vectorised_graph::VectorisedGraph,
-    },
+    prelude::{EdgeViewOps, StableDecode},
+    serialise::GraphPaths,
+    vectors::{storage::LazyDiskVectorCache, vectorised_graph::VectorisedGraph},
 };
 use raphtory_storage::{
-    core_ops::InheritCoreGraphOps, graph::graph::GraphStorage, layer_ops::InheritLayerOps,
-    mutation::InheritMutationOps,
+    core_ops::InheritCoreGraphOps, layer_ops::InheritLayerOps, mutation::InheritMutationOps,
+};
+use std::sync::{
+    atomic::{AtomicBool, Ordering},
+    Arc,
 };
 
-#[cfg(feature = "storage")]
-use {raphtory::prelude::IntoGraph, raphtory_storage::disk::DiskGraphStorage};
+#[cfg(feature = "search")]
+use raphtory::prelude::IndexMutationOps;
 
 #[derive(Clone)]
 pub struct GraphWithVectors {
     pub graph: MaterializedGraph,
     pub vectors: Option<VectorisedGraph<MaterializedGraph>>,
-    pub(crate) folder: OnceCell<GraphFolder>,
+    pub(crate) folder: ExistingGraphFolder,
+    pub(crate) is_dirty: Arc<AtomicBool>,
 }
 
 impl GraphWithVectors {
     pub(crate) fn new(
         graph: MaterializedGraph,
         vectors: Option<VectorisedGraph<MaterializedGraph>>,
+        folder: ExistingGraphFolder,
     ) -> Self {
         Self {
             graph,
             vectors,
-            folder: Default::default(),
+            folder,
+            is_dirty: Arc::new(AtomicBool::new(false)),
         }
     }
 
+    pub(crate) fn set_dirty(&self, is_dirty: bool) {
+        self.is_dirty.store(is_dirty, Ordering::SeqCst);
+    }
+
+    pub(crate) fn is_dirty(&self) -> bool {
+        self.is_dirty.load(Ordering::SeqCst)
+    }
+
     /// Generates and stores embeddings for a batch of nodes.
     pub(crate) async fn update_node_embeddings<T: AsNodeRef>(
         &self,
@@ -70,57 +86,45 @@ impl GraphWithVectors {
         Ok(())
     }
 
-    pub(crate) fn write_updates(&self) -> Result<(), GraphError> {
-        match self.graph.core_graph() {
-            GraphStorage::Mem(_) | GraphStorage::Unlocked(_) => self.graph.write_updates(),
-            #[cfg(feature = "storage")]
-            GraphStorage::Disk(_) => Ok(()),
-        }
-    }
-
     pub(crate) async fn read_from_folder(
         folder: &ExistingGraphFolder,
         cache: &LazyDiskVectorCache,
         create_index: bool,
+        config: Config,
     ) -> Result<Self, GraphError> {
-        let graph_path = &folder.get_graph_path();
-        let graph = if graph_path.is_dir() {
-            get_disk_graph_from_path(folder)?
+        let folder_clone = folder.clone();
+        let graph_folder = folder.graph_folder();
+        let graph = if graph_folder.read_metadata()?.is_diskgraph {
+            blocking_compute(move || {
+                MaterializedGraph::load_with_config(folder_clone.graph_folder(), config)
+            })
+            .await?
         } else {
-            MaterializedGraph::load_cached(folder.clone())?
+            blocking_compute(move || {
+                MaterializedGraph::decode_with_config(folder_clone.graph_folder(), config)
+            })
+            .await?
         };
         let vectors =
-            VectorisedGraph::read_from_path(&folder.get_vectors_path(), graph.clone(), cache)
+            VectorisedGraph::read_from_path(&folder.vectors_path()?, graph.clone(), cache)
                 .await
                 .ok();
 
-        println!("Graph loaded = {}", folder.get_original_path_str());
+        println!("Graph loaded = {}", folder.local_path());
+        #[cfg(feature = "search")]
         if create_index {
             graph.create_index()?;
-            graph.write_updates()?;
         }
+
         Ok(Self {
             graph: graph.clone(),
             vectors,
-            folder: OnceCell::with_value(folder.clone().into()),
+            folder: folder.clone().into(),
+            is_dirty: Arc::new(AtomicBool::new(false)),
         })
     }
 }
 
-#[cfg(feature = "storage")]
-fn get_disk_graph_from_path(path: &ExistingGraphFolder) -> Result<MaterializedGraph, GraphError> {
-    let disk_graph = DiskGraphStorage::load_from_dir(&path.get_graph_path())
-        .map_err(|e| GraphError::LoadFailure(e.to_string()))?;
-    let graph: MaterializedGraph = disk_graph.into_graph().into(); // TODO: We currently have no way to identify disk graphs as MaterializedGraphs
-    println!("Disk Graph loaded = {}", path.get_original_path().display());
-    Ok(graph)
-}
-
-#[cfg(not(feature = "storage"))]
-fn get_disk_graph_from_path(path: &ExistingGraphFolder) -> Result<MaterializedGraph, GraphError> {
-    Err(GraphError::GraphNotFound(path.to_error_path()))
-}
-
 impl Base for GraphWithVectors {
     type Base = MaterializedGraph;
     #[inline]
diff --git a/raphtory-graphql/src/lib.rs b/raphtory-graphql/src/lib.rs
index acc6b85b44..d8ac617035 100644
--- a/raphtory-graphql/src/lib.rs
+++ b/raphtory-graphql/src/lib.rs
@@ -1,5 +1,15 @@
-pub use crate::server::GraphServer;
+pub use crate::{
+    auth::{require_jwt_write_access_dynamic, Access},
+    model::graph::filtering::GraphAccessFilter,
+    server::GraphServer,
+};
+use crate::{data::InsertionError, paths::PathValidationError};
+use raphtory::errors::GraphError;
+use std::sync::Arc;
+
 mod auth;
+pub mod auth_policy;
+pub mod client;
 pub mod data;
 mod graph;
 pub mod model;
@@ -15,26 +25,48 @@ pub mod config;
 pub mod python;
 pub mod rayon;
 
+#[derive(thiserror::Error, Debug)]
+pub enum GQLError {
+    #[error(transparent)]
+    GraphError(#[from] GraphError),
+    #[error(transparent)]
+    Validation(#[from] PathValidationError),
+    #[error("Insertion failed for Graph {graph}: {error}")]
+    Insertion {
+        graph: String,
+        error: InsertionError,
+    },
+    #[error(transparent)]
+    Arc(#[from] Arc<Self>),
+}
+
 #[cfg(test)]
 mod graphql_test {
+    #[cfg(feature = "search")]
+    use crate::config::app_config::AppConfigBuilder;
     use crate::{
-        config::app_config::{AppConfig, AppConfigBuilder},
+        auth::Access,
+        config::app_config::AppConfig,
         data::{data_tests::save_graphs_to_work_dir, Data},
         model::App,
-        url_encode::{url_decode_graph, url_encode_graph},
+        url_encode::{url_decode_graph_at, url_encode_graph},
     };
-    use arrow_array::types::UInt8Type;
     use async_graphql::{dynamic::Schema, UploadValue};
     use dynamic_graphql::{Request, Variables};
+    use itertools::Itertools;
     use raphtory::{
         db::{
-            api::view::{IntoDynamic, MaterializedGraph},
+            api::{
+                storage::storage::Config,
+                view::{IntoDynamic, MaterializedGraph},
+            },
             graph::views::deletion_graph::PersistentGraph,
         },
         prelude::*,
         serialise::GraphFolder,
+        test_utils::json_sort_by_name,
     };
-    use raphtory_api::core::storage::arc_str::ArcStr;
+    use raphtory_api::core::{entities::GID, storage::arc_str::ArcStr};
     use serde_json::{json, Value};
     use std::{
         collections::{HashMap, HashSet},
@@ -42,6 +74,28 @@ mod graphql_test {
     };
     use tempfile::tempdir;
 
+    #[tokio::test]
+    async fn test_copy_graph() {
+        let graph = Graph::new();
+        graph.add_node(1, "test", NO_PROPS, None, None).unwrap();
+        let tmp_dir = tempdir().unwrap();
+        let data = Data::new(tmp_dir.path(), &AppConfig::default(), Config::default());
+        let namespace = tmp_dir.path().join("test");
+        fs::create_dir(&namespace).unwrap();
+        graph.encode(namespace.join("g3")).unwrap();
+        let schema = App::create_schema().data(data).finish().unwrap();
+        let query = r#"mutation {
+            copyGraph(
+                path: "test/g3",
+                newPath: "test/g4",
+            )
+        }"#;
+
+        let req = Request::new(query).data(Access::Rw);
+        let res = schema.execute(req).await;
+        assert_eq!(res.errors, []);
+    }
+
     #[tokio::test]
     #[cfg(feature = "search")]
     async fn test_search_nodes_gql() {
@@ -76,7 +130,7 @@ mod graphql_test {
         ];
 
         for (id, name, props) in nodes {
-            graph.add_node(id, name, props, None).unwrap();
+            graph.add_node(id, name, props, None, None).unwrap();
         }
 
         let metadata = vec![
@@ -99,12 +153,9 @@ mod graphql_test {
 
         let graphs = HashMap::from([("master".to_string(), graph)]);
         let tmp_dir = tempdir().unwrap();
-        save_graphs_to_work_dir(tmp_dir.path(), &graphs)
-            .await
-            .unwrap();
-
         let config = AppConfigBuilder::new().with_create_index(true).build();
-        let data = Data::new(tmp_dir.path(), &config);
+        let data = Data::new(tmp_dir.path(), &config, Config::default());
+        save_graphs_to_work_dir(&data, &graphs).await.unwrap();
 
         let schema = App::create_schema().data(data).finish().unwrap();
 
@@ -199,18 +250,15 @@ mod graphql_test {
     async fn basic_query() {
         let graph = PersistentGraph::new();
         graph
-            .add_node(0, 11, NO_PROPS, None)
+            .add_node(0, 11, NO_PROPS, None, None)
             .expect("Could not add node!");
         graph.add_metadata([("name", "lotr")]).unwrap();
 
         let graph: MaterializedGraph = graph.into();
         let graphs = HashMap::from([("lotr".to_string(), graph)]);
         let tmp_dir = tempdir().unwrap();
-        save_graphs_to_work_dir(tmp_dir.path(), &graphs)
-            .await
-            .unwrap();
-
-        let data = Data::new(tmp_dir.path(), &AppConfig::default());
+        let data = Data::new(tmp_dir.path(), &AppConfig::default(), Config::default());
+        save_graphs_to_work_dir(&data, &graphs).await.unwrap();
 
         let schema = App::create_schema().data(data).finish().unwrap();
 
@@ -236,7 +284,7 @@ mod graphql_test {
                     "nodes": {
                         "list": [
                             {
-                                "id": "11"
+                                "id": 11
                             }
                         ]
                     }
@@ -257,6 +305,7 @@ mod graphql_test {
                     ("cost", Prop::F32(99.5)),
                 ],
                 Some("a"),
+                None,
             )
             .unwrap();
         graph
@@ -268,6 +317,7 @@ mod graphql_test {
                     ("cost", Prop::F32(10.0)),
                 ],
                 Some("a"),
+                None,
             )
             .unwrap();
         graph
@@ -279,6 +329,7 @@ mod graphql_test {
                     ("cost", Prop::F32(76.0)),
                 ],
                 Some("a"),
+                None,
             )
             .unwrap();
         graph
@@ -319,11 +370,9 @@ mod graphql_test {
 
         let graphs = HashMap::from([("graph".to_string(), graph)]);
         let tmp_dir = tempdir().unwrap();
-        save_graphs_to_work_dir(tmp_dir.path(), &graphs)
-            .await
-            .unwrap();
+        let data = Data::new(tmp_dir.path(), &AppConfig::default(), Config::default());
+        save_graphs_to_work_dir(&data, &graphs).await.unwrap();
 
-        let data = Data::new(tmp_dir.path(), &AppConfig::default());
         let schema = App::create_schema().data(data).finish().unwrap();
         let prop_has_key_filter = r#"
         {
@@ -413,22 +462,15 @@ mod graphql_test {
     async fn query_nodefilter() {
         let graph = Graph::new();
         graph
-            .add_node(
-                0,
-                1,
-                [("pgraph", Prop::from_arr::<UInt8Type>(vec![3u8]))],
-                None,
-            )
+            .add_node(0, 1, [("pgraph", Prop::I32(0))], None, None)
             .unwrap();
         let graph: MaterializedGraph = graph.into();
 
         let graphs = HashMap::from([("graph".to_string(), graph)]);
         let tmp_dir = tempdir().unwrap();
-        save_graphs_to_work_dir(tmp_dir.path(), &graphs)
-            .await
-            .unwrap();
+        let data = Data::new(tmp_dir.path(), &AppConfig::default(), Config::default());
+        save_graphs_to_work_dir(&data, &graphs).await.unwrap();
 
-        let data = Data::new(tmp_dir.path(), &AppConfig::default());
         let schema = App::create_schema().data(data).finish().unwrap();
         let prop_has_key_filter = r#"
         {
@@ -484,138 +526,79 @@ mod graphql_test {
         g.add_edge(9, 1, 2, [("state", true)], None).unwrap();
         g.add_edge(10, 1, 2, [("state", false)], None).unwrap();
         g.add_edge(6, 1, 2, NO_PROPS, None).unwrap();
-        g.add_node(11, 3, [("name", "phone")], None).unwrap();
-        g.add_node(12, 3, [("name", "fax")], None).unwrap();
-        g.add_node(13, 3, [("name", "fax")], None).unwrap();
+        g.add_node(11, 3, [("name", "phone")], None, None).unwrap();
+        g.add_node(12, 3, [("name", "fax")], None, None).unwrap();
+        g.add_node(13, 3, [("name", "fax")], None, None).unwrap();
 
         let graph: MaterializedGraph = g.into();
         let graphs = HashMap::from([("graph".to_string(), graph)]);
         let tmp_dir = tempdir().unwrap();
-        save_graphs_to_work_dir(tmp_dir.path(), &graphs)
-            .await
-            .unwrap();
+        let data = Data::new(tmp_dir.path(), &AppConfig::default(), Config::default());
+        save_graphs_to_work_dir(&data, &graphs).await.unwrap();
 
-        let expected = json!({
-            "graph": {
-              "properties": {
-                "temporal": {
-                  "values": [
-                    {
-                      "unique": [
-                        "xyz",
-                        "abc"
-                      ]
-                    }
-                  ]
-                }
-              },
-              "node": {
-                "properties": {
-                  "temporal": {
-                    "values": [
-                      {
-                        "unique": [
-                          "fax",
-                          "phone"
-                        ]
-                      }
-                    ]
-                  }
+        let schema = App::create_schema().data(data).finish().unwrap();
+
+        // Query each `unique` by key so we can assert the typed element shape
+        // (strings for string props, bools for bool props — not stringified).
+        let query = r#"
+        {
+          graph(path: "graph") {
+            properties {
+              temporal {
+                get(key: "state") { unique }
+              }
+            }
+            node(name: "3") {
+              properties {
+                temporal {
+                  get(key: "name") { unique }
                 }
-              },
-              "edge": {
-                "properties": {
-                  "temporal": {
-                    "values": [
-                      {
-                        "unique": [
-                          "open",
-                          "review",
-                          "in-progress"
-                        ]
-                      },
-                      {
-                        "unique": [
-                          "false",
-                          "true"
-                        ]
-                      }
-                    ]
-                  }
+              }
+            }
+            edge(src: "1", dst: "2") {
+              properties {
+                temporal {
+                  status: get(key: "status") { unique }
+                  state:  get(key: "state")  { unique }
                 }
               }
             }
-        });
+          }
+        }
+        "#;
 
-        let mut actual_graph_props = HashSet::new();
-        let mut actual_node_props = HashSet::new();
-        let mut actual_edge_props = HashSet::new();
+        let req = Request::new(query);
+        let res = schema.execute(req).await;
+        assert!(res.errors.is_empty(), "errors: {:?}", res.errors);
+        let data = res.data.into_json().unwrap();
 
-        let graph_props = &expected["graph"]["properties"]["temporal"]["values"];
-        for value in graph_props.as_array().unwrap().iter() {
-            let unique_values: HashSet<_> = value["unique"]
-                .as_array()
-                .unwrap()
-                .iter()
-                .map(|v| v.as_str().unwrap())
-                .collect();
-            actual_graph_props.extend(unique_values);
+        fn sorted_unique<'a>(v: &'a Value) -> Vec<&'a Value> {
+            let mut out: Vec<&Value> = v["unique"].as_array().unwrap().iter().collect();
+            // serde_json::Value has a deterministic total order for same-typed values
+            // and groups by type for mixed inputs — fine for this test.
+            out.sort_by(|a, b| a.to_string().cmp(&b.to_string()));
+            out
         }
 
-        let node_props = &expected["graph"]["node"]["properties"]["temporal"]["values"];
-        for value in node_props.as_array().unwrap().iter() {
-            let unique_values: HashSet<_> = value["unique"]
-                .as_array()
-                .unwrap()
-                .iter()
-                .map(|v| v.as_str().unwrap())
-                .collect();
-            actual_node_props.extend(unique_values);
-        }
+        // graph-level `state` is a string property
+        let state = sorted_unique(&data["graph"]["properties"]["temporal"]["get"]);
+        assert_eq!(state, vec![&json!("abc"), &json!("xyz")]);
 
-        let edge_props = &expected["graph"]["edge"]["properties"]["temporal"]["values"];
-        for value in edge_props.as_array().unwrap().iter() {
-            let unique_values: HashSet<_> = value["unique"]
-                .as_array()
-                .unwrap()
-                .iter()
-                .map(|v| v.as_str().unwrap())
-                .collect();
-            actual_edge_props.extend(unique_values);
-        }
+        // node-level `name` is a string property
+        let name = sorted_unique(&data["graph"]["node"]["properties"]["temporal"]["get"]);
+        assert_eq!(name, vec![&json!("fax"), &json!("phone")]);
 
+        // edge-level `status` is a string property
+        let status = sorted_unique(&data["graph"]["edge"]["properties"]["temporal"]["status"]);
         assert_eq!(
-            actual_graph_props,
-            expected["graph"]["properties"]["temporal"]["values"][0]["unique"]
-                .as_array()
-                .unwrap()
-                .iter()
-                .map(|v| v.as_str().unwrap())
-                .collect::<HashSet<_>>()
-        );
-        assert_eq!(
-            actual_node_props,
-            expected["graph"]["node"]["properties"]["temporal"]["values"][0]["unique"]
-                .as_array()
-                .unwrap()
-                .iter()
-                .map(|v| v.as_str().unwrap())
-                .collect::<HashSet<_>>()
-        );
-        assert_eq!(
-            actual_edge_props,
-            expected["graph"]["edge"]["properties"]["temporal"]["values"]
-                .as_array()
-                .unwrap()
-                .iter()
-                .map(|value| value["unique"]
-                    .as_array()
-                    .unwrap()
-                    .iter()
-                    .map(|v| v.as_str().unwrap()))
-                .flatten()
-                .collect::<HashSet<_>>()
+            status,
+            vec![&json!("in-progress"), &json!("open"), &json!("review")]
         );
+
+        // edge-level `state` is a bool property — must come back as JSON bools,
+        // not strings "true" / "false".
+        let edge_state = sorted_unique(&data["graph"]["edge"]["properties"]["temporal"]["state"]);
+        assert_eq!(edge_state, vec![&json!(false), &json!(true)]);
     }
 
     #[tokio::test]
@@ -637,18 +620,16 @@ mod graphql_test {
         g.add_edge(9, 1, 2, [("state", true)], None).unwrap();
         g.add_edge(10, 1, 2, [("state", false)], None).unwrap();
         g.add_edge(6, 1, 2, NO_PROPS, None).unwrap();
-        g.add_node(11, 3, [("name", "phone")], None).unwrap();
-        g.add_node(12, 3, [("name", "fax")], None).unwrap();
-        g.add_node(13, 3, [("name", "fax")], None).unwrap();
+        g.add_node(11, 3, [("name", "phone")], None, None).unwrap();
+        g.add_node(12, 3, [("name", "fax")], None, None).unwrap();
+        g.add_node(13, 3, [("name", "fax")], None, None).unwrap();
 
         let g = g.into();
         let graphs = HashMap::from([("graph".to_string(), g)]);
         let tmp_dir = tempdir().unwrap();
-        save_graphs_to_work_dir(tmp_dir.path(), &graphs)
-            .await
-            .unwrap();
+        let data = Data::new(tmp_dir.path(), &AppConfig::default(), Config::default());
+        save_graphs_to_work_dir(&data, &graphs).await.unwrap();
 
-        let data = Data::new(tmp_dir.path(), &AppConfig::default());
         let schema = App::create_schema().data(data).finish().unwrap();
 
         let prop_has_key_filter = r#"
@@ -962,22 +943,15 @@ mod graphql_test {
     async fn query_properties() {
         let graph = Graph::new();
         graph
-            .add_node(
-                0,
-                1,
-                [("pgraph", Prop::from_arr::<UInt8Type>(vec![3u8]))],
-                None,
-            )
+            .add_node(0, 1, [("pgraph", Prop::I32(0))], None, None)
             .unwrap();
 
         let graph = graph.into();
         let graphs = HashMap::from([("graph".to_string(), graph)]);
         let tmp_dir = tempdir().unwrap();
-        save_graphs_to_work_dir(tmp_dir.path(), &graphs)
-            .await
-            .unwrap();
+        let data = Data::new(tmp_dir.path(), &AppConfig::default(), Config::default());
+        save_graphs_to_work_dir(&data, &graphs).await.unwrap();
 
-        let data = Data::new(tmp_dir.path(), &AppConfig::default());
         let schema = App::create_schema().data(data).finish().unwrap();
         let prop_has_key_filter = r#"
         {
@@ -1017,7 +991,7 @@ mod graphql_test {
     #[tokio::test]
     async fn test_graph_injection() {
         let g = PersistentGraph::new();
-        g.add_node(0, 1, NO_PROPS, None).unwrap();
+        g.add_node(0, 1, NO_PROPS, None, None).unwrap();
         let tmp_dir = tempfile::TempDir::new().unwrap();
         let zip_path = tmp_dir.path().join("graph.zip");
         g.encode(GraphFolder::new_as_zip(&zip_path)).unwrap();
@@ -1029,7 +1003,7 @@ mod graphql_test {
         };
 
         let tmp_dir = tempdir().unwrap();
-        let data = Data::new(tmp_dir.path(), &AppConfig::default());
+        let data = Data::new(tmp_dir.path(), &AppConfig::default(), Config::default());
         let schema = App::create_schema().data(data).finish().unwrap();
 
         let query = r##"
@@ -1039,7 +1013,9 @@ mod graphql_test {
         "##;
 
         let variables = json!({ "file": null, "overwrite": false });
-        let mut req = Request::new(query).variables(Variables::from_json(variables));
+        let mut req = Request::new(query)
+            .variables(Variables::from_json(variables))
+            .data(Access::Rw);
         req.set_upload("variables.file", upload_val);
         let res = schema.execute(req).await;
         assert_eq!(res.errors, vec![]);
@@ -1060,23 +1036,20 @@ mod graphql_test {
 
         let req = Request::new(list_nodes);
         let res = schema.execute(req).await;
-        assert_eq!(res.errors.len(), 0);
+        assert_eq!(res.errors, []);
         let res_json = res.data.into_json().unwrap();
-        assert_eq!(
-            res_json,
-            json!({"graph": {"nodes": {"list": [{"id": "1"}]}}})
-        );
+        assert_eq!(res_json, json!({"graph": {"nodes": {"list": [{"id": 1}]}}}));
     }
 
     #[tokio::test]
     async fn test_graph_send_receive_base64() {
         let g = PersistentGraph::new();
-        g.add_node(0, 1, NO_PROPS, None).unwrap();
+        g.add_node(0, 1, NO_PROPS, None, None).unwrap();
 
         let graph_str = url_encode_graph(g.clone()).unwrap();
 
         let tmp_dir = tempdir().unwrap();
-        let data = Data::new(tmp_dir.path(), &AppConfig::default());
+        let data = Data::new(tmp_dir.path(), &AppConfig::default(), Config::default());
         let schema = App::create_schema().data(data).finish().unwrap();
 
         let query = r#"
@@ -1084,12 +1057,14 @@ mod graphql_test {
             sendGraph(path: "test", graph: $graph, overwrite: $overwrite)
         }
         "#;
-        let req = Request::new(query).variables(Variables::from_json(
-            json!({ "graph": graph_str, "overwrite": false }),
-        ));
+        let req = Request::new(query)
+            .variables(Variables::from_json(
+                json!({ "graph": graph_str, "overwrite": false }),
+            ))
+            .data(Access::Rw);
 
         let res = schema.execute(req).await;
-        assert_eq!(res.errors.len(), 0);
+        assert_eq!(res.errors, []);
         let res_json = res.data.into_json().unwrap();
         assert_eq!(res_json, json!({"sendGraph": "test"}));
 
@@ -1109,10 +1084,7 @@ mod graphql_test {
         let res = schema.execute(req).await;
         assert_eq!(res.errors.len(), 0);
         let res_json = res.data.into_json().unwrap();
-        assert_eq!(
-            res_json,
-            json!({"graph": {"nodes": {"list": [{"id": "1"}]}}})
-        );
+        assert_eq!(res_json, json!({"graph": {"nodes": {"list": [{"id": 1}]}}}));
 
         let receive_graph = r#"
         query {
@@ -1125,7 +1097,11 @@ mod graphql_test {
         assert_eq!(res.errors.len(), 0);
         let res_json = res.data.into_json().unwrap();
         let graph_encoded = res_json.get("receiveGraph").unwrap().as_str().unwrap();
-        let graph_roundtrip = url_decode_graph(graph_encoded).unwrap().into_dynamic();
+        let temp_dir = tempdir().unwrap();
+        let graph_roundtrip =
+            url_decode_graph_at(graph_encoded, temp_dir.path(), Config::default())
+                .unwrap()
+                .into_dynamic();
         assert_eq!(g, graph_roundtrip);
     }
 
@@ -1133,12 +1109,12 @@ mod graphql_test {
     async fn test_type_filter() {
         let graph = Graph::new();
         graph.add_metadata([("name", "graph")]).unwrap();
-        graph.add_node(1, 1, NO_PROPS, Some("a")).unwrap();
-        graph.add_node(1, 2, NO_PROPS, Some("b")).unwrap();
-        graph.add_node(1, 3, NO_PROPS, Some("b")).unwrap();
-        graph.add_node(1, 4, NO_PROPS, Some("a")).unwrap();
-        graph.add_node(1, 5, NO_PROPS, Some("c")).unwrap();
-        graph.add_node(1, 6, NO_PROPS, Some("e")).unwrap();
+        graph.add_node(1, 1, NO_PROPS, Some("a"), None).unwrap();
+        graph.add_node(1, 2, NO_PROPS, Some("b"), None).unwrap();
+        graph.add_node(1, 3, NO_PROPS, Some("b"), None).unwrap();
+        graph.add_node(1, 4, NO_PROPS, Some("a"), None).unwrap();
+        graph.add_node(1, 5, NO_PROPS, Some("c"), None).unwrap();
+        graph.add_node(1, 6, NO_PROPS, Some("e"), None).unwrap();
         graph.add_edge(2, 1, 2, NO_PROPS, Some("a")).unwrap();
         graph.add_edge(2, 3, 2, NO_PROPS, Some("a")).unwrap();
         graph.add_edge(2, 2, 4, NO_PROPS, Some("a")).unwrap();
@@ -1150,11 +1126,9 @@ mod graphql_test {
         let graph = graph.into();
         let graphs = HashMap::from([("graph".to_string(), graph)]);
         let tmp_dir = tempdir().unwrap();
-        save_graphs_to_work_dir(tmp_dir.path(), &graphs)
-            .await
-            .unwrap();
+        let data = Data::new(tmp_dir.path(), &AppConfig::default(), Config::default());
+        save_graphs_to_work_dir(&data, &graphs).await.unwrap();
 
-        let data = Data::new(tmp_dir.path(), &AppConfig::default());
         let schema = App::create_schema().data(data).finish().unwrap();
 
         let req = r#"
@@ -1173,7 +1147,7 @@ mod graphql_test {
 
         let req = Request::new(req);
         let res = schema.execute(req).await;
-        let data = res.data.into_json().unwrap();
+        let data = json_sort_by_name(res.data.into_json().unwrap());
         assert_eq!(
             data,
             json!({
@@ -1200,6 +1174,7 @@ mod graphql_test {
             nodes {
               typeFilter(nodeTypes: ["a"]) {
                 list {
+                  name
                   neighbours {
                     list {
                       name
@@ -1214,7 +1189,7 @@ mod graphql_test {
 
         let req = Request::new(req);
         let res = schema.execute(req).await;
-        let data = res.data.into_json().unwrap();
+        let data = json_sort_by_name(res.data.into_json().unwrap());
         assert_eq!(
             data,
             json!({
@@ -1223,7 +1198,8 @@ mod graphql_test {
                     "typeFilter": {
                       "list": [
                         {
-                          "neighbours": {
+                            "name": "1",
+                            "neighbours": {
                             "list": [
                               {
                                 "name": "2"
@@ -1232,7 +1208,8 @@ mod graphql_test {
                           }
                         },
                         {
-                          "neighbours": {
+                            "name": "4",
+                            "neighbours": {
                             "list": [
                               {
                                 "name": "2"
@@ -1255,12 +1232,12 @@ mod graphql_test {
     async fn test_paging() {
         let graph1 = Graph::new();
         graph1.add_metadata([("name", "graph1")]).unwrap();
-        graph1.add_node(1, 1, NO_PROPS, Some("a")).unwrap();
-        graph1.add_node(1, 2, NO_PROPS, Some("b")).unwrap();
-        graph1.add_node(1, 3, NO_PROPS, Some("b")).unwrap();
-        graph1.add_node(1, 4, NO_PROPS, Some("a")).unwrap();
-        graph1.add_node(1, 5, NO_PROPS, Some("c")).unwrap();
-        graph1.add_node(1, 6, NO_PROPS, Some("e")).unwrap();
+        graph1.add_node(1, 1, NO_PROPS, Some("a"), None).unwrap();
+        graph1.add_node(1, 2, NO_PROPS, Some("b"), None).unwrap();
+        graph1.add_node(1, 3, NO_PROPS, Some("b"), None).unwrap();
+        graph1.add_node(1, 4, NO_PROPS, Some("a"), None).unwrap();
+        graph1.add_node(1, 5, NO_PROPS, Some("c"), None).unwrap();
+        graph1.add_node(1, 6, NO_PROPS, Some("e"), None).unwrap();
         graph1.add_edge(2, 1, 2, NO_PROPS, Some("a")).unwrap();
         graph1.add_edge(2, 3, 2, NO_PROPS, Some("a")).unwrap();
         graph1.add_edge(2, 2, 4, NO_PROPS, Some("a")).unwrap();
@@ -1268,21 +1245,50 @@ mod graphql_test {
         graph1.add_edge(2, 4, 6, NO_PROPS, Some("a")).unwrap();
         graph1.add_edge(2, 5, 6, NO_PROPS, Some("a")).unwrap();
         graph1.add_edge(2, 3, 6, NO_PROPS, Some("a")).unwrap();
+
+        let all_nodes: Vec<_> = graph1.nodes().name().into_iter_values().collect();
+
+        // make sure we have the correct nodes
+        assert_eq!(
+            all_nodes.iter().sorted().collect_vec(),
+            ["1", "2", "3", "4", "5", "6"]
+        );
+        let all_edges: Vec<_> = graph1
+            .edges()
+            .id()
+            .map(|(src, dst)| {
+                let src = match src {
+                    GID::U64(u) => u,
+                    GID::Str(_) => unreachable!("integer-indexed graph"),
+                };
+                let dst = match dst {
+                    GID::U64(u) => u,
+                    GID::Str(_) => unreachable!("integer-indexed graph"),
+                };
+                (src, dst)
+            })
+            .collect();
+
+        // make sure we have the correct edges
+        assert_eq!(
+            all_edges.iter().cloned().sorted().collect_vec(),
+            [(1, 2), (2, 4), (3, 2), (3, 6), (4, 5), (4, 6), (5, 6),]
+        );
         let graph2 = Graph::new();
         graph2.add_metadata([("name", "graph2")]).unwrap();
-        graph2.add_node(1, 1, NO_PROPS, Some("a")).unwrap();
+        graph2.add_node(1, 1, NO_PROPS, Some("a"), None).unwrap();
         let graph3 = Graph::new();
         graph3.add_metadata([("name", "graph3")]).unwrap();
-        graph3.add_node(1, 1, NO_PROPS, Some("a")).unwrap();
+        graph3.add_node(1, 1, NO_PROPS, Some("a"), None).unwrap();
         let graph4 = Graph::new();
         graph4.add_metadata([("name", "graph4")]).unwrap();
-        graph4.add_node(1, 1, NO_PROPS, Some("a")).unwrap();
+        graph4.add_node(1, 1, NO_PROPS, Some("a"), None).unwrap();
         let graph5 = Graph::new();
         graph5.add_metadata([("name", "graph5")]).unwrap();
-        graph5.add_node(1, 1, NO_PROPS, Some("a")).unwrap();
+        graph5.add_node(1, 1, NO_PROPS, Some("a"), None).unwrap();
         let graph6 = Graph::new();
         graph6.add_metadata([("name", "graph6")]).unwrap();
-        graph6.add_node(1, 1, NO_PROPS, Some("a")).unwrap();
+        graph6.add_node(1, 1, NO_PROPS, Some("a"), None).unwrap();
 
         let graphs = HashMap::from([
             ("graph1".to_string(), graph1.into()),
@@ -1293,11 +1299,8 @@ mod graphql_test {
             ("graph6".to_string(), graph6.into()),
         ]);
         let tmp_dir = tempdir().unwrap();
-        save_graphs_to_work_dir(tmp_dir.path(), &graphs)
-            .await
-            .unwrap();
-
-        let data = Data::new(tmp_dir.path(), &AppConfig::default());
+        let data = Data::new(tmp_dir.path(), &AppConfig::default(), Config::default());
+        save_graphs_to_work_dir(&data, &graphs).await.unwrap();
         let schema = App::create_schema().data(data).finish().unwrap();
 
         let req = r#"
@@ -1315,22 +1318,16 @@ mod graphql_test {
         let req = Request::new(req);
         let res = schema.execute(req).await;
         let data = res.data.into_json().unwrap();
+        let expected_page: Vec<_> = all_nodes[1..4]
+            .iter()
+            .map(|node| json!({"name": node}))
+            .collect();
         assert_eq!(
             data,
             json!({
                 "graph": {
                     "nodes": {
-                        "page": [
-                            {
-                                "name": "2"
-                            },
-                            {
-                                "name": "3"
-                            },
-                            {
-                                "name": "4"
-                            }
-                        ]
+                        "page": expected_page
                     }
                 }
             }),
@@ -1377,19 +1374,16 @@ mod graphql_test {
         let req = Request::new(req);
         let res = schema.execute(req).await;
         let data = res.data.into_json().unwrap();
+        let expected_page: Vec<_> = all_nodes[2..4]
+            .iter()
+            .map(|node| json!({"name": node}))
+            .collect();
         assert_eq!(
             data,
             json!({
                 "graph": {
                     "nodes": {
-                        "page": [
-                            {
-                                "name": "3"
-                            },
-                            {
-                                "name": "4"
-                            }
-                        ]
+                        "page": expected_page
                     }
                 }
             }),
@@ -1410,19 +1404,16 @@ mod graphql_test {
         let req = Request::new(req);
         let res = schema.execute(req).await;
         let data = res.data.into_json().unwrap();
+        let expected_page: Vec<_> = all_edges[5..7]
+            .iter()
+            .map(|edge| json!({"id": edge}))
+            .collect();
         assert_eq!(
             data,
             json!({
                 "graph": {
                     "edges": {
-                        "page": [
-                            {
-                                "id": ["5", "6"]
-                            },
-                            {
-                                "id": ["3", "6"]
-                            }
-                        ]
+                        "page": expected_page
                     }
                 }
             }),
@@ -1443,16 +1434,16 @@ mod graphql_test {
         let req = Request::new(req);
         let res = schema.execute(req).await;
         let data = res.data.into_json().unwrap();
+        let expected_page: Vec<_> = all_edges[6..]
+            .iter()
+            .map(|edge| json!({"id": edge}))
+            .collect();
         assert_eq!(
             data,
             json!({
                 "graph": {
                     "edges": {
-                        "page": [
-                            {
-                                "id": ["3", "6"]
-                            },
-                        ]
+                        "page": expected_page
                     }
                 }
             }),
@@ -1495,92 +1486,16 @@ mod graphql_test {
         );
     }
 
-    #[cfg(feature = "storage")]
-    #[tokio::test]
-    async fn test_disk_graph() {
-        let graph = Graph::new();
-        graph.add_metadata([("name", "graph")]).unwrap();
-        graph.add_node(1, 1, NO_PROPS, Some("a")).unwrap();
-        graph.add_node(1, 2, NO_PROPS, Some("b")).unwrap();
-        graph.add_node(1, 3, NO_PROPS, Some("b")).unwrap();
-        graph.add_node(1, 4, NO_PROPS, Some("a")).unwrap();
-        graph.add_node(1, 5, NO_PROPS, Some("c")).unwrap();
-        graph.add_node(1, 6, NO_PROPS, Some("e")).unwrap();
-        graph.add_edge(22, 1, 2, NO_PROPS, Some("a")).unwrap();
-        graph.add_edge(22, 3, 2, NO_PROPS, Some("a")).unwrap();
-        graph.add_edge(22, 2, 4, NO_PROPS, Some("a")).unwrap();
-        graph.add_edge(22, 4, 5, NO_PROPS, Some("a")).unwrap();
-        graph.add_edge(22, 4, 5, NO_PROPS, Some("a")).unwrap();
-        graph.add_edge(22, 5, 6, NO_PROPS, Some("a")).unwrap();
-        graph.add_edge(22, 3, 6, NO_PROPS, Some("a")).unwrap();
-
-        let tmp_work_dir = tempdir().unwrap();
-        let tmp_work_dir = tmp_work_dir.path();
-
-        let disk_graph_path = tmp_work_dir.join("graph");
-        fs::create_dir(&disk_graph_path).unwrap();
-        fs::File::create(disk_graph_path.join(".raph")).unwrap();
-        let _ = DiskGraphStorage::from_graph(&graph, disk_graph_path.join("graph")).unwrap();
-
-        let data = Data::new(&tmp_work_dir, &AppConfig::default());
-        let schema = App::create_schema().data(data).finish().unwrap();
-
-        let req = r#"
-        {
-          graph(path: "graph") {
-            nodes {
-              list {
-                name
-              }
-            }
-          }
-        }
-        "#;
-
-        let req = Request::new(req);
-        let res = schema.execute(req).await;
-        let data = res.data.into_json().unwrap();
-        assert_eq!(
-            data,
-            json!({
-                "graph": {
-                  "nodes": {
-                      "list": [
-                        {
-                          "name": "1"
-                        },
-                        {
-                          "name": "2"
-                        },
-                        {
-                          "name": "3"
-                        },
-                        {
-                          "name": "4"
-                        },
-                        {
-                          "name": "5"
-                        },
-                        {
-                          "name": "6"
-                        }
-                      ]
-                  }
-                }
-            }),
-        );
-    }
-
     #[tokio::test]
     async fn test_query_namespace() {
         let graph = Graph::new();
         graph.add_metadata([("name", "graph")]).unwrap();
-        graph.add_node(1, 1, NO_PROPS, Some("a")).unwrap();
-        graph.add_node(1, 2, NO_PROPS, Some("b")).unwrap();
-        graph.add_node(1, 3, NO_PROPS, Some("b")).unwrap();
-        graph.add_node(1, 4, NO_PROPS, Some("a")).unwrap();
-        graph.add_node(1, 5, NO_PROPS, Some("c")).unwrap();
-        graph.add_node(1, 6, NO_PROPS, Some("e")).unwrap();
+        graph.add_node(1, 1, NO_PROPS, Some("a"), None).unwrap();
+        graph.add_node(1, 2, NO_PROPS, Some("b"), None).unwrap();
+        graph.add_node(1, 3, NO_PROPS, Some("b"), None).unwrap();
+        graph.add_node(1, 4, NO_PROPS, Some("a"), None).unwrap();
+        graph.add_node(1, 5, NO_PROPS, Some("c"), None).unwrap();
+        graph.add_node(1, 6, NO_PROPS, Some("e"), None).unwrap();
         graph.add_edge(2, 1, 2, NO_PROPS, Some("a")).unwrap();
         graph.add_edge(2, 3, 2, NO_PROPS, Some("a")).unwrap();
         graph.add_edge(2, 2, 4, NO_PROPS, Some("a")).unwrap();
@@ -1592,11 +1507,8 @@ mod graphql_test {
         let graph = graph.into();
         let graphs = HashMap::from([("graph".to_string(), graph)]);
         let tmp_dir = tempdir().unwrap();
-        save_graphs_to_work_dir(tmp_dir.path(), &graphs)
-            .await
-            .unwrap();
-
-        let data = Data::new(tmp_dir.path(), &AppConfig::default());
+        let data = Data::new(tmp_dir.path(), &AppConfig::default(), Config::default());
+        save_graphs_to_work_dir(&data, &graphs).await.unwrap();
         let schema = App::create_schema().data(data).finish().unwrap();
 
         let req = r#"
@@ -1661,7 +1573,7 @@ mod graphql_test {
           createSubgraph(parentPath: "graph", newPath: "graph2", nodes: ["1", "2"], overwrite: false)
         }
         "#;
-        let req = Request::new(req);
+        let req = Request::new(req).data(Access::Rw);
         let res = schema.execute(req).await;
         assert_eq!(res.errors, vec![]);
         let req = r#"
@@ -1669,7 +1581,7 @@ mod graphql_test {
           createSubgraph(parentPath: "graph", newPath: "namespace1/graph3", nodes: ["2", "3", "4"], overwrite: false)
         }
         "#;
-        let req = Request::new(req);
+        let req = Request::new(req).data(Access::Rw);
         let res = schema.execute(req).await;
         assert_eq!(res.errors, vec![]);
 
@@ -1853,7 +1765,8 @@ mod graphql_test {
     async fn test_new_graph(schema: &Schema, path: &str, should_work: bool) {
         let req = Request::new(format!(
             r#"mutation {{ newGraph(path: "{path}", graphType: EVENT) }}"#,
-        ));
+        ))
+        .data(Access::Rw);
         let res = schema.execute(req).await;
 
         if should_work {
@@ -1908,7 +1821,7 @@ mod graphql_test {
     #[tokio::test]
     async fn test_new_graph_rejects_hidden_path_components() {
         let tmp_dir = tempdir().unwrap();
-        let data = Data::new(tmp_dir.path(), &AppConfig::default());
+        let data = Data::new(tmp_dir.path(), &AppConfig::default(), Config::default());
         let schema = App::create_schema().data(data).finish().unwrap();
 
         // Valid paths
diff --git a/raphtory-graphql/src/model/graph/collection.rs b/raphtory-graphql/src/model/graph/collection.rs
index aa345e984a..f2b5b546d8 100644
--- a/raphtory-graphql/src/model/graph/collection.rs
+++ b/raphtory-graphql/src/model/graph/collection.rs
@@ -1,10 +1,42 @@
-use crate::rayon::blocking_compute;
+use crate::{config::concurrency_config::ConcurrencyConfig, rayon::blocking_compute};
+use async_graphql::{Context, Error, Result};
 use dynamic_graphql::{
     internal::{OutputTypeName, ResolveOwned, TypeName},
     ResolvedObject, ResolvedObjectFields,
 };
 use std::{borrow::Cow, sync::Arc};
 
+/// Returns an error when `concurrency.disable_lists` is set. Called from every `list`
+/// resolver on paginated collections.
+pub(crate) fn check_list_allowed(ctx: &Context<'_>) -> Result<()> {
+    if ctx
+        .data_opt::<ConcurrencyConfig>()
+        .map(|cfg| cfg.disable_lists)
+        .unwrap_or(false)
+    {
+        return Err(Error::new(
+            "Bulk list endpoints are disabled on this server. Use `page` instead.",
+        ));
+    }
+    Ok(())
+}
+
+/// Returns an error when `limit` exceeds `concurrency.max_page_size`. Called from every
+/// `page` resolver on paginated collections.
+pub(crate) fn check_page_limit(ctx: &Context<'_>, limit: usize) -> Result<()> {
+    if let Some(max) = ctx
+        .data_opt::<ConcurrencyConfig>()
+        .and_then(|cfg| cfg.max_page_size)
+    {
+        if limit > max {
+            return Err(Error::new(format!(
+                "page limit {limit} exceeds the maximum allowed page size {max}"
+            )));
+        }
+    }
+    Ok(())
+}
+
 /// Collection of items
 #[derive(ResolvedObject, Clone)]
 #[graphql(get_type_name = true)]
@@ -47,18 +79,31 @@ where
     T: for<'a> ResolveOwned<'a>,
 {
     /// Returns a list of collection objects.
-    async fn list(&self) -> Vec<T> {
+    async fn list(&self, ctx: &Context<'_>) -> Result<Vec<T>> {
+        check_list_allowed(ctx)?;
         let self_clone = self.clone();
-        blocking_compute(move || self_clone.items.to_vec()).await
+        Ok(blocking_compute(move || self_clone.items.to_vec()).await)
     }
 
     /// Fetch one page with a number of items up to a specified limit, optionally offset by a specified amount. The page_index sets the number of pages to skip (defaults to 0).
     ///
     /// For example, if page(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
     /// will be returned.
-    async fn page(&self, limit: usize, offset: Option<usize>, page_index: Option<usize>) -> Vec<T> {
+
+    async fn page(
+        &self,
+        ctx: &Context<'_>,
+        #[graphql(desc = "Maximum number of items to return on this page.")] limit: usize,
+        #[graphql(desc = "Extra items to skip on top of `pageIndex` paging (default 0).")]
+        offset: Option<usize>,
+        #[graphql(
+            desc = "Zero-based page number; multiplies `limit` to determine where to start (default 0)."
+        )]
+        page_index: Option<usize>,
+    ) -> Result<Vec<T>> {
+        check_page_limit(ctx, limit)?;
         let self_clone = self.clone();
-        blocking_compute(move || {
+        Ok(blocking_compute(move || {
             let start = page_index.unwrap_or(0) * limit + offset.unwrap_or(0);
             self_clone
                 .items
@@ -68,7 +113,7 @@ where
                 .cloned()
                 .collect()
         })
-        .await
+        .await)
     }
 
     /// Returns a count of collection objects.
diff --git a/raphtory-graphql/src/model/graph/edge.rs b/raphtory-graphql/src/model/graph/edge.rs
index db1d8b02f6..29fd37c6d4 100644
--- a/raphtory-graphql/src/model/graph/edge.rs
+++ b/raphtory-graphql/src/model/graph/edge.rs
@@ -4,6 +4,7 @@ use crate::{
         filtering::{EdgeViewCollection, GqlEdgeFilter},
         history::GqlHistory,
         node::GqlNode,
+        node_id::GqlNodeId,
         property::{GqlMetadata, GqlProperties},
         timeindex::{GqlEventTime, GqlTimeInput},
         windowset::GqlEdgeWindowSet,
@@ -61,7 +62,11 @@ impl GqlEdge {
     /// Returns a view of Edge containing all layers in the list of names.
     ///
     /// Errors if any of the layers do not exist.
-    async fn layers(&self, names: Vec<String>) -> GqlEdge {
+
+    async fn layers(
+        &self,
+        #[graphql(desc = "Layer names to include.")] names: Vec<String>,
+    ) -> GqlEdge {
         let self_clone = self.clone();
         blocking_compute(move || self_clone.ee.valid_layers(names).into()).await
     }
@@ -69,7 +74,11 @@ impl GqlEdge {
     /// Returns a view of Edge containing all layers except the excluded list of names.
     ///
     /// Errors if any of the layers do not exist.
-    async fn exclude_layers(&self, names: Vec<String>) -> GqlEdge {
+
+    async fn exclude_layers(
+        &self,
+        #[graphql(desc = "Layer names to exclude.")] names: Vec<String>,
+    ) -> GqlEdge {
         let self_clone = self.clone();
         blocking_compute(move || self_clone.ee.exclude_valid_layers(names).into()).await
     }
@@ -77,14 +86,19 @@ impl GqlEdge {
     /// Returns a view of Edge containing the specified layer.
     ///
     /// Errors if any of the layers do not exist.
-    async fn layer(&self, name: String) -> GqlEdge {
+
+    async fn layer(&self, #[graphql(desc = "Layer name to include.")] name: String) -> GqlEdge {
         self.ee.valid_layers(name).into()
     }
 
     /// Returns a view of Edge containing all layers except the excluded layer specified.
     ///
     /// Errors if any of the layers do not exist.
-    async fn exclude_layer(&self, name: String) -> GqlEdge {
+
+    async fn exclude_layer(
+        &self,
+        #[graphql(desc = "Layer name to exclude.")] name: String,
+    ) -> GqlEdge {
         self.ee.exclude_valid_layers(name).into()
     }
 
@@ -97,10 +111,20 @@ impl GqlEdge {
     /// e.g. "1 month and 1 day" will align at the start of the day.
     /// Note that passing a step larger than window while alignment_unit is not "Unaligned" may lead to some entries appearing before
     /// the start of the first window and/or after the end of the last window (i.e. not included in any window).
+
     async fn rolling(
         &self,
+        #[graphql(
+            desc = "Width of each window. Pass either `{epoch: <ms>}` for a discrete number of milliseconds (e.g. `{epoch: 1000}` for 1 second), or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}` or `{duration: 2 hours and 30 minutes}`)."
+        )]
         window: WindowDuration,
+        #[graphql(
+            desc = "Optional gap between the start of one window and the start of the next. Accepts the same `{epoch: <ms>}` or `{duration: <text>}` values as `window`. Defaults to `window` — i.e. windows touch end-to-end with no overlap and no gap."
+        )]
         step: Option<WindowDuration>,
+        #[graphql(
+            desc = "Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step` (or `window` if no step is set)."
+        )]
         alignment_unit: Option<GqlAlignmentUnit>,
     ) -> Result<GqlEdgeWindowSet, GraphError> {
         let window = window.try_into_interval()?;
@@ -120,9 +144,16 @@ impl GqlEdge {
     /// alignment_unit optionally aligns the windows to the specified unit. "Unaligned" can be passed for no alignment.
     /// If unspecified (i.e. by default), alignment is done on the smallest unit of time in the step.
     /// e.g. "1 month and 1 day" will align at the start of the day.
+
     async fn expanding(
         &self,
+        #[graphql(
+            desc = "How much the window grows by on each step. Pass either `{epoch: <ms>}` for a discrete number of milliseconds, or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}`)."
+        )]
         step: WindowDuration,
+        #[graphql(
+            desc = "Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step`."
+        )]
         alignment_unit: Option<GqlAlignmentUnit>,
     ) -> Result<GqlEdgeWindowSet, GraphError> {
         let step = step.try_into_interval()?;
@@ -137,16 +168,28 @@ impl GqlEdge {
     /// Creates a view of the Edge including all events between the specified start (inclusive) and end (exclusive).
     ///
     /// For persistent graphs, any edge which exists at any point during the window will be included. You may want to restrict this to only edges that are present at the end of the window using the is_valid function.
-    async fn window(&self, start: GqlTimeInput, end: GqlTimeInput) -> GqlEdge {
+
+    async fn window(
+        &self,
+        #[graphql(desc = "Inclusive lower bound.")] start: GqlTimeInput,
+        #[graphql(desc = "Exclusive upper bound.")] end: GqlTimeInput,
+    ) -> GqlEdge {
         self.ee.window(start.into_time(), end.into_time()).into()
     }
 
     /// Creates a view of the Edge including all events at a specified time.
-    async fn at(&self, time: GqlTimeInput) -> GqlEdge {
+
+    async fn at(
+        &self,
+        #[graphql(desc = "Instant to pin the view to.")] time: GqlTimeInput,
+    ) -> GqlEdge {
         self.ee.at(time.into_time()).into()
     }
 
-    /// Returns a view of the edge at the latest time of the graph.
+    /// View of this edge pinned to the graph's latest time — equivalent to
+    /// `at(graph.latestTime)`. The edge's properties and metadata show their
+    /// most recent values, and (for persistent graphs) validity is evaluated
+    /// at that instant.
     async fn latest(&self) -> GqlEdge {
         self.ee.latest().into()
     }
@@ -154,7 +197,11 @@ impl GqlEdge {
     /// Creates a view of the Edge including all events that are valid at time.
     ///
     /// This is equivalent to before(time + 1) for Graph and at(time) for PersistentGraph.
-    async fn snapshot_at(&self, time: GqlTimeInput) -> GqlEdge {
+
+    async fn snapshot_at(
+        &self,
+        #[graphql(desc = "Instant at which entities must be valid.")] time: GqlTimeInput,
+    ) -> GqlEdge {
         self.ee.snapshot_at(time.into_time()).into()
     }
 
@@ -166,34 +213,66 @@ impl GqlEdge {
     }
 
     /// Creates a view of the Edge including all events before a specified end (exclusive).
-    async fn before(&self, time: GqlTimeInput) -> GqlEdge {
+
+    async fn before(
+        &self,
+        #[graphql(desc = "Exclusive upper bound.")] time: GqlTimeInput,
+    ) -> GqlEdge {
         self.ee.before(time.into_time()).into()
     }
 
     /// Creates a view of the Edge including all events after a specified start (exclusive).
-    async fn after(&self, time: GqlTimeInput) -> GqlEdge {
+
+    async fn after(
+        &self,
+        #[graphql(desc = "Exclusive lower bound.")] time: GqlTimeInput,
+    ) -> GqlEdge {
         self.ee.after(time.into_time()).into()
     }
 
     /// Shrinks both the start and end of the window.
-    async fn shrink_window(&self, start: GqlTimeInput, end: GqlTimeInput) -> Self {
+
+    async fn shrink_window(
+        &self,
+        #[graphql(desc = "Proposed new start (TimeInput); ignored if it would widen the window.")]
+        start: GqlTimeInput,
+        #[graphql(desc = "Proposed new end (TimeInput); ignored if it would widen the window.")]
+        end: GqlTimeInput,
+    ) -> Self {
         self.ee
             .shrink_window(start.into_time(), end.into_time())
             .into()
     }
 
     /// Set the start of the window.
-    async fn shrink_start(&self, start: GqlTimeInput) -> Self {
+
+    async fn shrink_start(
+        &self,
+        #[graphql(desc = "Proposed new start (TimeInput); ignored if it would widen the window.")]
+        start: GqlTimeInput,
+    ) -> Self {
         self.ee.shrink_start(start.into_time()).into()
     }
 
     /// Set the end of the window.
-    async fn shrink_end(&self, end: GqlTimeInput) -> Self {
+
+    async fn shrink_end(
+        &self,
+        #[graphql(desc = "Proposed new end (TimeInput); ignored if it would widen the window.")]
+        end: GqlTimeInput,
+    ) -> Self {
         self.ee.shrink_end(end.into_time()).into()
     }
 
     /// Takes a specified selection of views and applies them in given order.
-    async fn apply_views(&self, views: Vec<EdgeViewCollection>) -> Result<GqlEdge, GraphError> {
+
+    async fn apply_views(
+        &self,
+        #[graphql(
+            desc = "Ordered list of view operations; each entry is a one-of variant (`window`, `layer`, `filter`, ...) applied to the running result."
+        )]
+        views: Vec<EdgeViewCollection>,
+    ) -> Result<GqlEdge, GraphError> {
         let mut return_view: GqlEdge = self.ee.clone().into();
         for view in views {
             return_view = match view {
@@ -248,6 +327,10 @@ impl GqlEdge {
         self.ee.earliest_time().into()
     }
 
+    /// The timestamp of the first event in this edge's history (first update, first
+    /// deletion, or anything in between). Differs from `earliestTime` in that
+    /// `earliestTime` reports when the edge is first *valid*; `firstUpdate` reports
+    /// when its history actually begins.
     async fn first_update(&self) -> GqlEventTime {
         let self_clone = self.clone();
         blocking_compute(move || self_clone.ee.history().earliest_time().into()).await
@@ -258,6 +341,10 @@ impl GqlEdge {
         self.ee.latest_time().into()
     }
 
+    /// The timestamp of the last event in this edge's history (last update, last
+    /// deletion, or anything in between). Differs from `latestTime` in that
+    /// `latestTime` reports when the edge is last *valid*; `lastUpdate` reports
+    /// when its history actually ends.
     async fn last_update(&self) -> GqlEventTime {
         let self_clone = self.clone();
         blocking_compute(move || self_clone.ee.history().latest_time().into()).await
@@ -302,13 +389,12 @@ impl GqlEdge {
         self.ee.nbr().into()
     }
 
-    /// Returns the id of the edge.
-    ///
-    /// Returns:
-    ///     list[str]:
-    async fn id(&self) -> Vec<String> {
-        let (src_name, dst_name) = self.ee.id();
-        vec![src_name.to_string(), dst_name.to_string()]
+    /// Returns the `[src, dst]` id pair of the edge. Each id is a `String`
+    /// for string-indexed graphs or a non-negative `Int` for integer-indexed
+    /// graphs.
+    async fn id(&self) -> Vec<GqlNodeId> {
+        let (src_id, dst_id) = self.ee.id();
+        vec![GqlNodeId(src_id), GqlNodeId(dst_id)]
     }
 
     /// Returns a view of the properties of the edge.
@@ -393,7 +479,14 @@ impl GqlEdge {
         self.ee.is_self_loop()
     }
 
-    async fn filter(&self, expr: GqlEdgeFilter) -> Result<Self, GraphError> {
+    /// Apply an edge filter in place, returning an edge view whose properties /
+    /// metadata / history are restricted to the matching subset.
+
+    async fn filter(
+        &self,
+        #[graphql(desc = "Composite edge filter (by property, layer, src/dst, etc.).")]
+        expr: GqlEdgeFilter,
+    ) -> Result<Self, GraphError> {
         let self_clone = self.clone();
         blocking_compute(move || {
             let filter: CompositeEdgeFilter = expr.try_into()?;
diff --git a/raphtory-graphql/src/model/graph/edges.rs b/raphtory-graphql/src/model/graph/edges.rs
index f83d21c67d..084e2d37c3 100644
--- a/raphtory-graphql/src/model/graph/edges.rs
+++ b/raphtory-graphql/src/model/graph/edges.rs
@@ -1,6 +1,7 @@
 use crate::{
     model::{
         graph::{
+            collection::{check_list_allowed, check_page_limit},
             edge::GqlEdge,
             filtering::EdgesViewCollection,
             timeindex::{GqlEventTime, GqlTimeInput},
@@ -11,6 +12,7 @@ use crate::{
     },
     rayon::blocking_compute,
 };
+use async_graphql::Context;
 use dynamic_graphql::{ResolvedObject, ResolvedObjectFields};
 use itertools::Itertools;
 use raphtory::{
@@ -30,6 +32,9 @@ use raphtory::db::{
     api::view::Filter, graph::views::filter::model::edge_filter::CompositeEdgeFilter,
 };
 
+/// A lazy collection of edges from a graph view. Supports the usual view
+/// transforms (window, layer, filter, ...), plus edge-specific ones like
+/// `explode` and `explodeLayers`, pagination, and sorting.
 #[derive(ResolvedObject, Clone)]
 #[graphql(name = "Edges")]
 pub(crate) struct GqlEdges {
@@ -68,24 +73,37 @@ impl GqlEdges {
     }
 
     /// Returns a collection containing only edges belonging to the listed layers.
-    async fn layers(&self, names: Vec<String>) -> Self {
+
+    async fn layers(
+        &self,
+        #[graphql(desc = "Layer names to include.")] names: Vec<String>,
+    ) -> Self {
         let self_clone = self.clone();
         blocking_compute(move || self_clone.update(self_clone.ee.valid_layers(names))).await
     }
 
     /// Returns a collection containing edges belonging to all layers except the excluded list of layers.
-    async fn exclude_layers(&self, names: Vec<String>) -> Self {
+
+    async fn exclude_layers(
+        &self,
+        #[graphql(desc = "Layer names to exclude.")] names: Vec<String>,
+    ) -> Self {
         let self_clone = self.clone();
         blocking_compute(move || self_clone.update(self_clone.ee.exclude_valid_layers(names))).await
     }
 
     /// Returns a collection containing edges belonging to the specified layer.
-    async fn layer(&self, name: String) -> Self {
+
+    async fn layer(&self, #[graphql(desc = "Layer name to include.")] name: String) -> Self {
         self.update(self.ee.valid_layers(name))
     }
 
     /// Returns a collection containing edges belonging to all layers except the excluded layer specified.
-    async fn exclude_layer(&self, name: String) -> Self {
+
+    async fn exclude_layer(
+        &self,
+        #[graphql(desc = "Layer name to exclude.")] name: String,
+    ) -> Self {
         self.update(self.ee.exclude_valid_layers(name))
     }
 
@@ -98,10 +116,20 @@ impl GqlEdges {
     /// e.g. "1 month and 1 day" will align at the start of the day.
     /// Note that passing a step larger than window while alignment_unit is not "Unaligned" may lead to some entries appearing before
     /// the start of the first window and/or after the end of the last window (i.e. not included in any window).
+
     async fn rolling(
         &self,
+        #[graphql(
+            desc = "Width of each window. Pass either `{epoch: <ms>}` for a discrete number of milliseconds (e.g. `{epoch: 1000}` for 1 second), or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}` or `{duration: 2 hours and 30 minutes}`)."
+        )]
         window: WindowDuration,
+        #[graphql(
+            desc = "Optional gap between the start of one window and the start of the next. Accepts the same `{epoch: <ms>}` or `{duration: <text>}` values as `window`. Defaults to `window` — i.e. windows touch end-to-end with no overlap and no gap."
+        )]
         step: Option<WindowDuration>,
+        #[graphql(
+            desc = "Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step` (or `window` if no step is set)."
+        )]
         alignment_unit: Option<GqlAlignmentUnit>,
     ) -> Result<GqlEdgesWindowSet, GraphError> {
         let window = window.try_into_interval()?;
@@ -121,9 +149,16 @@ impl GqlEdges {
     /// alignment_unit optionally aligns the windows to the specified unit. "Unaligned" can be passed for no alignment.
     /// If unspecified (i.e. by default), alignment is done on the smallest unit of time in the step.
     /// e.g. "1 month and 1 day" will align at the start of the day.
+
     async fn expanding(
         &self,
+        #[graphql(
+            desc = "How much the window grows by on each step. Pass either `{epoch: <ms>}` for a discrete number of milliseconds, or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}`)."
+        )]
         step: WindowDuration,
+        #[graphql(
+            desc = "Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step`."
+        )]
         alignment_unit: Option<GqlAlignmentUnit>,
     ) -> Result<GqlEdgesWindowSet, GraphError> {
         let step = step.try_into_interval()?;
@@ -136,15 +171,25 @@ impl GqlEdges {
     }
 
     /// Creates a view of the Edge including all events between the specified start (inclusive) and end (exclusive).
-    async fn window(&self, start: GqlTimeInput, end: GqlTimeInput) -> Self {
+
+    async fn window(
+        &self,
+        #[graphql(desc = "Inclusive lower bound.")] start: GqlTimeInput,
+        #[graphql(desc = "Exclusive upper bound.")] end: GqlTimeInput,
+    ) -> Self {
         self.update(self.ee.window(start.into_time(), end.into_time()))
     }
 
     /// Creates a view of the Edge including all events at a specified time.
-    async fn at(&self, time: GqlTimeInput) -> Self {
+
+    async fn at(
+        &self,
+        #[graphql(desc = "Instant to pin the view to.")] time: GqlTimeInput,
+    ) -> Self {
         self.update(self.ee.at(time.into_time()))
     }
 
+    /// View showing only the latest state of each edge (equivalent to `at(latestTime)`).
     async fn latest(&self) -> Self {
         let e = self.ee.clone();
         let latest = blocking_compute(move || e.latest()).await;
@@ -152,7 +197,11 @@ impl GqlEdges {
     }
 
     /// Creates a view of the Edge including all events that are valid at time. This is equivalent to before(time + 1) for Graph and at(time) for PersistentGraph.
-    async fn snapshot_at(&self, time: GqlTimeInput) -> Self {
+
+    async fn snapshot_at(
+        &self,
+        #[graphql(desc = "Instant at which entities must be valid.")] time: GqlTimeInput,
+    ) -> Self {
         self.update(self.ee.snapshot_at(time.into_time()))
     }
 
@@ -162,32 +211,58 @@ impl GqlEdges {
     }
 
     /// Creates a view of the Edge including all events before a specified end (exclusive).
-    async fn before(&self, time: GqlTimeInput) -> Self {
+
+    async fn before(&self, #[graphql(desc = "Exclusive upper bound.")] time: GqlTimeInput) -> Self {
         self.update(self.ee.before(time.into_time()))
     }
 
     /// Creates a view of the Edge including all events after a specified start (exclusive).
-    async fn after(&self, time: GqlTimeInput) -> Self {
+
+    async fn after(&self, #[graphql(desc = "Exclusive lower bound.")] time: GqlTimeInput) -> Self {
         self.update(self.ee.after(time.into_time()))
     }
 
     /// Shrinks both the start and end of the window.
-    async fn shrink_window(&self, start: GqlTimeInput, end: GqlTimeInput) -> Self {
+
+    async fn shrink_window(
+        &self,
+        #[graphql(desc = "Proposed new start (TimeInput); ignored if it would widen the window.")]
+        start: GqlTimeInput,
+        #[graphql(desc = "Proposed new end (TimeInput); ignored if it would widen the window.")]
+        end: GqlTimeInput,
+    ) -> Self {
         self.update(self.ee.shrink_window(start.into_time(), end.into_time()))
     }
 
     /// Set the start of the window.
-    async fn shrink_start(&self, start: GqlTimeInput) -> Self {
+
+    async fn shrink_start(
+        &self,
+        #[graphql(desc = "Proposed new start (TimeInput); ignored if it would widen the window.")]
+        start: GqlTimeInput,
+    ) -> Self {
         self.update(self.ee.shrink_start(start.into_time()))
     }
 
     /// Set the end of the window.
-    async fn shrink_end(&self, end: GqlTimeInput) -> Self {
+
+    async fn shrink_end(
+        &self,
+        #[graphql(desc = "Proposed new end (TimeInput); ignored if it would widen the window.")]
+        end: GqlTimeInput,
+    ) -> Self {
         self.update(self.ee.shrink_end(end.into_time()))
     }
 
     /// Takes a specified selection of views and applies them in order given.
-    async fn apply_views(&self, views: Vec<EdgesViewCollection>) -> Result<GqlEdges, GraphError> {
+
+    async fn apply_views(
+        &self,
+        #[graphql(
+            desc = "Ordered list of view operations; each entry is a one-of variant (`window`, `layer`, `filter`, ...) applied to the running result."
+        )]
+        views: Vec<EdgesViewCollection>,
+    ) -> Result<GqlEdges, GraphError> {
         let mut return_view: GqlEdges = self.update(self.ee.clone());
         for view in views {
             return_view = match view {
@@ -236,7 +311,9 @@ impl GqlEdges {
         Ok(return_view)
     }
 
-    /// Returns an edge object for each update within the original edge.
+    /// Expand each edge into one edge per update: if `A->B` has three updates, it
+    /// becomes three `A->B` entries each at a distinct timestamp. Use this to
+    /// iterate per-event rather than per-edge.
     async fn explode(&self) -> Self {
         self.update(self.ee.explode())
     }
@@ -248,8 +325,16 @@ impl GqlEdges {
         self.update(self.ee.explode_layers())
     }
 
-    /// Specify a sort order from: source, destination, property, time. You can also reverse the ordering.
-    async fn sorted(&self, sort_bys: Vec<EdgeSortBy>) -> Self {
+    /// Sort the edges. Multiple criteria are applied lexicographically (ties
+    /// on the first key break to the second, etc.).
+
+    async fn sorted(
+        &self,
+        #[graphql(
+            desc = "Ordered list of sort keys. Each entry chooses exactly one of `src` / `dst` / `time` / `property`, with an optional `reverse: true` to flip order."
+        )]
+        sort_bys: Vec<EdgeSortBy>,
+    ) -> Self {
         let self_clone = self.clone();
         blocking_compute(move || {
             let sorted: Arc<[_]> = self_clone
@@ -342,28 +427,55 @@ impl GqlEdges {
     ///
     /// For example, if page(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
     /// will be returned.
+
     async fn page(
         &self,
-        limit: usize,
+        ctx: &Context<'_>,
+        #[graphql(desc = "Maximum number of items to return on this page.")] limit: usize,
+        #[graphql(desc = "Extra items to skip on top of `pageIndex` paging (default 0).")]
         offset: Option<usize>,
+        #[graphql(
+            desc = "Zero-based page number; multiplies `limit` to determine where to start (default 0)."
+        )]
         page_index: Option<usize>,
-    ) -> Vec<GqlEdge> {
+    ) -> async_graphql::Result<Vec<GqlEdge>> {
+        check_page_limit(ctx, limit)?;
         let self_clone = self.clone();
-        blocking_compute(move || {
+        Ok(blocking_compute(move || {
             let start = page_index.unwrap_or(0) * limit + offset.unwrap_or(0);
             self_clone.iter().skip(start).take(limit).collect()
         })
-        .await
+        .await)
     }
 
     /// Returns a list of all objects in the current selection of the collection. You should filter the collection first then call list.
-    async fn list(&self) -> Vec<GqlEdge> {
+    async fn list(&self, ctx: &Context<'_>) -> async_graphql::Result<Vec<GqlEdge>> {
+        check_list_allowed(ctx)?;
         let self_clone = self.clone();
-        blocking_compute(move || self_clone.iter().collect()).await
+        Ok(blocking_compute(move || self_clone.iter().collect()).await)
     }
 
-    /// Returns a filtered view that applies to list down the chain
-    async fn filter(&self, expr: GqlEdgeFilter) -> Result<Self, GraphError> {
+    /// Narrow the collection to edges matching `expr`. The filter sticks to the
+    /// returned view — every subsequent traversal through these edges (their
+    /// properties, their endpoints' neighbours, etc.) continues to see the
+    /// filtered scope.
+    ///
+    /// Useful when you want one scoping rule to apply across the whole query.
+    /// E.g. restricting everything to a specific week:
+    ///
+    /// ```text
+    /// edges { filter(expr: {window: {start: 1234, end: 5678}}) {
+    ///   list { src { neighbours { list { name } } } }   # neighbours still windowed
+    /// } }
+    /// ```
+    ///
+    /// Contrast with `select`, which applies here and is not carried through.
+
+    async fn filter(
+        &self,
+        #[graphql(desc = "Composite edge filter (by property, layer, src/dst, etc.).")]
+        expr: GqlEdgeFilter,
+    ) -> Result<Self, GraphError> {
         let self_clone = self.clone();
         blocking_compute(move || {
             let filter: CompositeEdgeFilter = expr.try_into()?;
@@ -373,8 +485,30 @@ impl GqlEdges {
         .await
     }
 
-    /// Returns filtered list of edges
-    async fn select(&self, expr: GqlEdgeFilter) -> Result<Self, GraphError> {
+    /// Narrow the collection to edges matching `expr`, but only at this step —
+    /// subsequent traversals out of these edges see the unfiltered graph again.
+    ///
+    /// Useful when you want different scopes at different hops. E.g. Monday's
+    /// edges, then the neighbours of their endpoints on Tuesday, then *those*
+    /// neighbours on Wednesday:
+    ///
+    /// ```text
+    /// edges { select(expr: {window: {...monday...}}) {
+    ///   list { src { select(expr: {window: {...tuesday...}}) {
+    ///     neighbours { select(expr: {window: {...wednesday...}}) {
+    ///       neighbours { list { name } }
+    ///     } }
+    ///   } } }
+    /// } }
+    /// ```
+    ///
+    /// Contrast with `filter`, which persists the scope through subsequent ops.
+
+    async fn select(
+        &self,
+        #[graphql(desc = "Composite edge filter (by property, layer, src/dst, etc.).")]
+        expr: GqlEdgeFilter,
+    ) -> Result<Self, GraphError> {
         let self_clone = self.clone();
         blocking_compute(move || {
             let filter: CompositeEdgeFilter = expr.try_into()?;
diff --git a/raphtory-graphql/src/model/graph/filtering.rs b/raphtory-graphql/src/model/graph/filtering.rs
index fdbfd8187e..0309e7dc6f 100644
--- a/raphtory-graphql/src/model/graph/filtering.rs
+++ b/raphtory-graphql/src/model/graph/filtering.rs
@@ -1,4 +1,4 @@
-use crate::model::graph::{property::Value, timeindex::GqlTimeInput};
+use crate::model::graph::{node_id::GqlNodeId, property::Value, timeindex::GqlTimeInput};
 use async_graphql::dynamic::ValueAccessor;
 use dynamic_graphql::{
     internal::{
@@ -30,7 +30,9 @@ use raphtory::{
 use raphtory_api::core::{
     entities::{properties::prop::Prop, Layer, GID},
     storage::timeindex::{AsTime, EventTime},
+    utils::time::IntoTime,
 };
+use serde::{Deserialize, Serialize};
 use std::{
     borrow::Cow,
     collections::HashSet,
@@ -40,7 +42,7 @@ use std::{
     sync::Arc,
 };
 
-#[derive(InputObject, Clone, Debug)]
+#[derive(InputObject, Clone, Debug, Serialize, Deserialize)]
 pub struct Window {
     /// Window start time.
     pub start: GqlTimeInput,
@@ -59,11 +61,11 @@ pub enum GraphViewCollection {
     /// Single excluded layer.
     ExcludeLayer(String),
     /// Subgraph nodes.
-    Subgraph(Vec<String>),
+    Subgraph(Vec<GqlNodeId>),
     /// Subgraph node types.
     SubgraphNodeTypes(Vec<String>),
     /// List of excluded nodes.
-    ExcludeNodes(Vec<String>),
+    ExcludeNodes(Vec<GqlNodeId>),
     /// Valid state.
     Valid(bool),
     /// Window between a start and end time.
@@ -260,7 +262,8 @@ pub enum PathFromNodeViewCollection {
     ShrinkEnd(GqlTimeInput),
 }
 
-#[derive(Enum, Copy, Clone, Debug)]
+#[derive(Enum, Copy, Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
 pub enum NodeField {
     /// Node ID field.
     ///
@@ -303,7 +306,7 @@ impl Display for NodeField {
 /// ```graphql
 /// { Property: { name: "weight", where: { Gt: 0.5 } } }
 /// ```
-#[derive(InputObject, Clone, Debug)]
+#[derive(InputObject, Clone, Debug, Serialize, Deserialize)]
 pub struct PropertyFilterNew {
     /// Property (or metadata) key.
     pub name: String,
@@ -311,6 +314,7 @@ pub struct PropertyFilterNew {
     ///
     /// Exposed as `where` in GraphQL.
     #[graphql(name = "where")]
+    #[serde(rename = "where")]
     pub where_: PropCondition,
 }
 
@@ -331,7 +335,8 @@ pub struct PropertyFilterNew {
 /// - `Value` is interpreted according to the property’s type.
 /// - Aggregators/qualifiers like `Sum` and `Len` apply when the underlying
 ///   property is list-like or aggregatable (depending on your engine rules).
-#[derive(OneOfInput, Clone, Debug)]
+#[derive(OneOfInput, Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
 pub enum PropCondition {
     /// Equality: property value equals the given value.
     Eq(Value),
@@ -448,7 +453,7 @@ impl PropCondition {
 /// ```graphql
 /// { Window: { start: 0, end: 10, expr: { Layers: { names: ["A"] } } } }
 /// ```
-#[derive(InputObject, Clone, Debug)]
+#[derive(InputObject, Clone, Debug, Serialize, Deserialize)]
 pub struct GraphWindowExpr {
     /// Window start time (inclusive).
     pub start: GqlTimeInput,
@@ -464,7 +469,7 @@ pub struct GraphWindowExpr {
 ///
 /// Example:
 /// `{ At: { time: 5, expr: { Layers: { names: ["L1"] } } } }`
-#[derive(InputObject, Clone, Debug)]
+#[derive(InputObject, Clone, Debug, Serialize, Deserialize)]
 pub struct GraphTimeExpr {
     /// Reference time for the operation.
     pub time: GqlTimeInput,
@@ -475,7 +480,7 @@ pub struct GraphTimeExpr {
 /// Graph view restriction that takes only a nested expression.
 ///
 /// Used for unary view operations like `Latest` and `SnapshotLatest`.
-#[derive(InputObject, Clone, Debug)]
+#[derive(InputObject, Clone, Debug, Serialize, Deserialize)]
 pub struct GraphUnaryExpr {
     /// Optional nested filter applied after the unary operation.
     pub expr: Option<Wrapped<GqlGraphFilter>>,
@@ -484,7 +489,7 @@ pub struct GraphUnaryExpr {
 /// Graph view restriction by layer membership, optionally chaining another `GraphFilter`.
 ///
 /// Used by `GqlGraphFilter::Layers`.
-#[derive(InputObject, Clone, Debug)]
+#[derive(InputObject, Clone, Debug, Serialize, Deserialize)]
 pub struct GraphLayersExpr {
     /// Layer names to include.
     pub names: Vec<String>,
@@ -504,8 +509,9 @@ pub struct GraphLayersExpr {
 ///
 /// These filters can be nested via the `expr` field on the corresponding
 /// `*Expr` input objects to form pipelines.
-#[derive(OneOfInput, Clone, Debug)]
+#[derive(OneOfInput, Clone, Debug, Serialize, Deserialize)]
 #[graphql(name = "GraphFilter")]
+#[serde(rename_all = "camelCase")]
 pub enum GqlGraphFilter {
     /// Restrict evaluation to a time window (inclusive start, exclusive end).
     Window(GraphWindowExpr),
@@ -534,7 +540,8 @@ pub enum GqlGraphFilter {
 ///
 /// Supports comparisons, string predicates, and set membership.
 /// (Presence checks and aggregations are handled via property filters instead.)
-#[derive(OneOfInput, Clone, Debug)]
+#[derive(OneOfInput, Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
 pub enum NodeFieldCondition {
     /// Equality.
     Eq(Value),
@@ -590,7 +597,7 @@ impl NodeFieldCondition {
 /// ```graphql
 /// { Node: { field: NodeName, where: { Contains: "ali" } } }
 /// ```
-#[derive(InputObject, Clone, Debug)]
+#[derive(InputObject, Clone, Debug, Serialize, Deserialize)]
 pub struct NodeFieldFilterNew {
     /// Which built-in field to filter.
     pub field: NodeField,
@@ -598,6 +605,7 @@ pub struct NodeFieldFilterNew {
     ///
     /// Exposed as `where` in GraphQL.
     #[graphql(name = "where")]
+    #[serde(rename = "where")]
     pub where_: NodeFieldCondition,
 }
 
@@ -606,7 +614,7 @@ pub struct NodeFieldFilterNew {
 /// Used by `GqlNodeFilter::Window`.
 ///
 /// The window is inclusive of `start` and exclusive of `end`.
-#[derive(InputObject, Clone, Debug)]
+#[derive(InputObject, Clone, Debug, Serialize, Deserialize)]
 pub struct NodeWindowExpr {
     /// Window start time (inclusive).
     pub start: GqlTimeInput,
@@ -619,7 +627,7 @@ pub struct NodeWindowExpr {
 /// Restricts node evaluation to a single time bound and applies a nested `NodeFilter`.
 ///
 /// Used by `At`, `Before`, and `After` node filters.
-#[derive(InputObject, Clone, Debug)]
+#[derive(InputObject, Clone, Debug, Serialize, Deserialize)]
 pub struct NodeTimeExpr {
     /// Reference time for the operation.
     pub time: GqlTimeInput,
@@ -630,7 +638,7 @@ pub struct NodeTimeExpr {
 /// Applies a unary node-view operation and then evaluates a nested `NodeFilter`.
 ///
 /// Used by `Latest` and `SnapshotLatest` node filters.
-#[derive(InputObject, Clone, Debug)]
+#[derive(InputObject, Clone, Debug, Serialize, Deserialize)]
 pub struct NodeUnaryExpr {
     /// Filter evaluated after applying the unary operation.
     pub expr: Wrapped<GqlNodeFilter>,
@@ -639,7 +647,7 @@ pub struct NodeUnaryExpr {
 /// Restricts node evaluation to one or more layers and applies a nested `NodeFilter`.
 ///
 /// Used by `GqlNodeFilter::Layers`.
-#[derive(InputObject, Clone, Debug)]
+#[derive(InputObject, Clone, Debug, Serialize, Deserialize)]
 pub struct NodeLayersExpr {
     /// Layer names to include.
     pub names: Vec<String>,
@@ -661,8 +669,9 @@ pub struct NodeLayersExpr {
 ///
 /// Filters can be combined recursively using logical operators
 /// (`And`, `Or`, `Not`).
-#[derive(OneOfInput, Clone, Debug)]
+#[derive(OneOfInput, Clone, Debug, Serialize, Deserialize)]
 #[graphql(name = "NodeFilter")]
+#[serde(rename_all = "camelCase")]
 pub enum GqlNodeFilter {
     /// Filters a built-in node field (ID, name, or type).
     Node(NodeFieldFilterNew),
@@ -718,7 +727,7 @@ pub enum GqlNodeFilter {
 /// Used by `GqlEdgeFilter::Window`.
 ///
 /// The window is inclusive of `start` and exclusive of `end`.
-#[derive(InputObject, Clone, Debug)]
+#[derive(InputObject, Clone, Debug, Serialize, Deserialize)]
 pub struct EdgeWindowExpr {
     /// Window start time (inclusive).
     pub start: GqlTimeInput,
@@ -731,7 +740,7 @@ pub struct EdgeWindowExpr {
 /// Restricts edge evaluation to a single time bound and applies a nested `EdgeFilter`.
 ///
 /// Used by `At`, `Before`, and `After` edge filters.
-#[derive(InputObject, Clone, Debug)]
+#[derive(InputObject, Clone, Debug, Serialize, Deserialize)]
 pub struct EdgeTimeExpr {
     /// Reference time for the operation.
     pub time: GqlTimeInput,
@@ -742,7 +751,7 @@ pub struct EdgeTimeExpr {
 /// Applies a unary edge-view operation and then evaluates a nested `EdgeFilter`.
 ///
 /// Used by `Latest` and `SnapshotLatest` edge filters.
-#[derive(InputObject, Clone, Debug)]
+#[derive(InputObject, Clone, Debug, Serialize, Deserialize)]
 pub struct EdgeUnaryExpr {
     /// Filter evaluated after applying the unary operation.
     pub expr: Wrapped<GqlEdgeFilter>,
@@ -751,7 +760,7 @@ pub struct EdgeUnaryExpr {
 /// Restricts edge evaluation to one or more layers and applies a nested `EdgeFilter`.
 ///
 /// Used by `GqlEdgeFilter::Layers`.
-#[derive(InputObject, Clone, Debug)]
+#[derive(InputObject, Clone, Debug, Serialize, Deserialize)]
 pub struct EdgeLayersExpr {
     /// Layer names to include.
     pub names: Vec<String>,
@@ -787,8 +796,9 @@ pub struct EdgeLayersExpr {
 ///   }
 /// }
 /// ```
-#[derive(OneOfInput, Clone, Debug)]
+#[derive(OneOfInput, Clone, Debug, Serialize, Deserialize)]
 #[graphql(name = "EdgeFilter")]
+#[serde(rename_all = "camelCase")]
 pub enum GqlEdgeFilter {
     /// Applies a filter to the **source node** of the edge.
     ///
@@ -903,7 +913,8 @@ pub enum GqlEdgeFilter {
     IsSelfLoop(bool),
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(transparent)]
 pub struct Wrapped<T>(Box<T>);
 impl<T> Deref for Wrapped<T> {
     type Target = T;
@@ -1416,13 +1427,15 @@ impl TryFrom<GqlNodeFilter> for CompositeNodeFilter {
             GqlNodeFilter::Window(w) => {
                 let inner: CompositeNodeFilter = w.expr.deref().clone().try_into()?;
                 Ok(CompositeNodeFilter::Windowed(Box::new(Windowed::new(
-                    w.start.0, w.end.0, inner,
+                    w.start.into_time(),
+                    w.end.into_time(),
+                    inner,
                 ))))
             }
 
             GqlNodeFilter::At(t) => {
                 let inner: CompositeNodeFilter = t.expr.deref().clone().try_into()?;
-                let et: EventTime = t.time.0;
+                let et = t.time.into_time();
                 Ok(CompositeNodeFilter::Windowed(Box::new(Windowed::new(
                     et,
                     EventTime::end(et.t().saturating_add(1)),
@@ -1434,14 +1447,14 @@ impl TryFrom<GqlNodeFilter> for CompositeNodeFilter {
                 let inner: CompositeNodeFilter = t.expr.deref().clone().try_into()?;
                 Ok(CompositeNodeFilter::Windowed(Box::new(Windowed::new(
                     EventTime::start(i64::MIN),
-                    EventTime::end(t.time.0.t()),
+                    EventTime::end(t.time.t()),
                     inner,
                 ))))
             }
 
             GqlNodeFilter::After(t) => {
                 let inner: CompositeNodeFilter = t.expr.deref().clone().try_into()?;
-                let start = EventTime::start(t.time.0.t().saturating_add(1));
+                let start = EventTime::start(t.time.t().saturating_add(1));
                 Ok(CompositeNodeFilter::Windowed(Box::new(Windowed::new(
                     start,
                     EventTime::end(i64::MAX),
@@ -1459,7 +1472,7 @@ impl TryFrom<GqlNodeFilter> for CompositeNodeFilter {
             GqlNodeFilter::SnapshotAt(t) => {
                 let inner: CompositeNodeFilter = t.expr.deref().clone().try_into()?;
                 Ok(CompositeNodeFilter::SnapshotAt(Box::new(
-                    SnapshotAtWrap::new(t.time.0, inner),
+                    SnapshotAtWrap::new(t.time.into_time(), inner),
                 )))
             }
 
@@ -1581,13 +1594,15 @@ impl TryFrom<GqlEdgeFilter> for CompositeEdgeFilter {
             GqlEdgeFilter::Window(w) => {
                 let inner: CompositeEdgeFilter = w.expr.deref().clone().try_into()?;
                 Ok(CompositeEdgeFilter::Windowed(Box::new(Windowed::new(
-                    w.start.0, w.end.0, inner,
+                    w.start.into_time(),
+                    w.end.into_time(),
+                    inner,
                 ))))
             }
 
             GqlEdgeFilter::At(t) => {
                 let inner: CompositeEdgeFilter = t.expr.deref().clone().try_into()?;
-                let et: EventTime = t.time.0;
+                let et = t.time.into_time();
                 Ok(CompositeEdgeFilter::Windowed(Box::new(Windowed::new(
                     et,
                     EventTime::end(et.t().saturating_add(1)),
@@ -1599,14 +1614,14 @@ impl TryFrom<GqlEdgeFilter> for CompositeEdgeFilter {
                 let inner: CompositeEdgeFilter = t.expr.deref().clone().try_into()?;
                 Ok(CompositeEdgeFilter::Windowed(Box::new(Windowed::new(
                     EventTime::start(i64::MIN),
-                    EventTime::end(t.time.0.t()),
+                    EventTime::end(t.time.t()),
                     inner,
                 ))))
             }
 
             GqlEdgeFilter::After(t) => {
                 let inner: CompositeEdgeFilter = t.expr.deref().clone().try_into()?;
-                let start = EventTime::start(t.time.0.t().saturating_add(1));
+                let start = EventTime::start(t.time.t().saturating_add(1));
                 Ok(CompositeEdgeFilter::Windowed(Box::new(Windowed::new(
                     start,
                     EventTime::end(i64::MAX),
@@ -1624,7 +1639,7 @@ impl TryFrom<GqlEdgeFilter> for CompositeEdgeFilter {
             GqlEdgeFilter::SnapshotAt(t) => {
                 let inner: CompositeEdgeFilter = t.expr.deref().clone().try_into()?;
                 Ok(CompositeEdgeFilter::SnapshotAt(Box::new(
-                    SnapshotAtWrap::new(t.time.0, inner),
+                    SnapshotAtWrap::new(t.time.into_time(), inner),
                 )))
             }
 
@@ -1734,3 +1749,23 @@ impl TryFrom<GqlGraphFilter> for DynView {
         })
     }
 }
+
+/// Combined filter input covering all three filter levels (node, edge, graph-level).
+/// Used by `grantGraphFilteredReadOnly` to express a data-access restriction
+/// that is transparently applied whenever the role queries the graph.
+/// Use `and` / `or` to compose multiple sub-filters.
+#[derive(OneOfInput, Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum GraphAccessFilter {
+    /// Filter by node properties, fields, or temporal state.
+    Node(GqlNodeFilter),
+    /// Filter by edge properties, source/destination, or temporal state.
+    Edge(GqlEdgeFilter),
+    /// Apply a graph-level view (window, snapshot, layer restriction, …).
+    Graph(GqlGraphFilter),
+    /// All sub-filters must pass (intersection).
+    And(Vec<GraphAccessFilter>),
+    /// At least one sub-filter must pass (union within each filter type;
+    /// cross-type sub-filters are applied as independent restrictions).
+    Or(Vec<GraphAccessFilter>),
+}
diff --git a/raphtory-graphql/src/model/graph/graph.rs b/raphtory-graphql/src/model/graph/graph.rs
index 13bfccc535..3a76bece60 100644
--- a/raphtory-graphql/src/model/graph/graph.rs
+++ b/raphtory-graphql/src/model/graph/graph.rs
@@ -1,5 +1,6 @@
 use crate::{
     data::Data,
+    graph::GraphWithVectors,
     model::{
         graph::{
             edge::GqlEdge,
@@ -7,6 +8,7 @@ use crate::{
             filtering::{GqlEdgeFilter, GqlGraphFilter, GqlNodeFilter, GraphViewCollection},
             index::GqlIndexSpec,
             node::GqlNode,
+            node_id::GqlNodeId,
             nodes::GqlNodes,
             property::{GqlMetadata, GqlProperties},
             timeindex::{GqlEventTime, GqlTimeInput},
@@ -16,12 +18,15 @@ use crate::{
         plugins::graph_algorithm_plugin::GraphAlgorithmPlugin,
         schema::graph_schema::GraphSchema,
     },
-    paths::ExistingGraphFolder,
+    paths::{ExistingGraphFolder, PathValidationError, ValidGraphPaths},
     rayon::blocking_compute,
+    GQLError,
 };
 use async_graphql::Context;
-use dynamic_graphql::{ResolvedObject, ResolvedObjectFields};
+use dynamic_graphql::{ResolvedObject, ResolvedObjectFields, Result};
 use itertools::Itertools;
+#[cfg(feature = "search")]
+use raphtory::db::api::view::SearchableGraphOps;
 use raphtory::{
     core::{
         entities::nodes::node_ref::{AsNodeRef, NodeRef},
@@ -32,7 +37,7 @@ use raphtory::{
             properties::dyn_props::DynProperties,
             view::{
                 filter_ops::NodeSelect, DynamicGraph, EdgeSelect, Filter, IntoDynamic, NodeViewOps,
-                SearchableGraphOps, StaticGraphViewOps, TimeOps,
+                StaticGraphViewOps, TimeOps,
             },
         },
         graph::{
@@ -43,7 +48,7 @@ use raphtory::{
             },
         },
     },
-    errors::{GraphError, InvalidPathReason},
+    errors::GraphError,
     prelude::*,
 };
 use raphtory_api::core::{storage::timeindex::AsTime, utils::time::IntoTime};
@@ -53,6 +58,9 @@ use std::{
     sync::Arc,
 };
 
+/// A view of a Raphtory graph. Every field here returns either data from the
+/// view or a derived view (`window`, `layer`, `at`, `filter`, ...) that you can
+/// keep chaining. Views are cheap — they don't copy the underlying data.
 #[derive(ResolvedObject, Clone)]
 #[graphql(name = "Graph")]
 pub(crate) struct GqlGraph {
@@ -60,6 +68,12 @@ pub(crate) struct GqlGraph {
     graph: DynamicGraph,
 }
 
+impl From<GraphWithVectors> for GqlGraph {
+    fn from(value: GraphWithVectors) -> Self {
+        GqlGraph::new(value.folder, value.graph)
+    }
+}
+
 impl GqlGraph {
     pub fn new<G: StaticGraphViewOps + IntoDynamic>(path: ExistingGraphFolder, graph: G) -> Self {
         Self {
@@ -87,58 +101,101 @@ impl GqlGraph {
     ////////////////////////
 
     /// Returns the names of all layers in the graphview.
+    /// Distinct layer names observed in the current view — any layer that has at
+    /// least one edge event visible here. Excludes layers that exist elsewhere in
+    /// the graph but whose edges have been filtered out.
     async fn unique_layers(&self) -> Vec<String> {
         let self_clone = self.clone();
         blocking_compute(move || self_clone.graph.unique_layers().map_into().collect()).await
     }
 
-    /// Returns a view containing only the default layer.
+    /// View restricted to the default layer — where nodes and edges end up
+    /// when `addNode` / `addEdge` is called without a `layer` argument.
+    /// Useful for separating "unlayered" base-graph events from named-layer
+    /// ones.
     async fn default_layer(&self) -> GqlGraph {
         self.apply(|g| g.default_layer())
     }
 
-    /// Returns a view containing all the specified layers.
-    async fn layers(&self, names: Vec<String>) -> GqlGraph {
+    /// View restricted to the named layers. Updates on any other layer are hidden;
+    /// if that leaves a node or edge with no updates left, it disappears from the
+    /// view.
+
+    async fn layers(
+        &self,
+        #[graphql(desc = "Layer names to include.")] names: Vec<String>,
+    ) -> GqlGraph {
         let self_clone = self.clone();
         blocking_compute(move || self_clone.apply(|g| g.valid_layers(names.clone()))).await
     }
 
-    /// Returns a view containing all layers except the specified excluded layers.
-    async fn exclude_layers(&self, names: Vec<String>) -> GqlGraph {
+    /// View with the named layers hidden. Updates on those layers are removed; if
+    /// that leaves a node or edge with no updates left, it disappears from the
+    /// view.
+
+    async fn exclude_layers(
+        &self,
+        #[graphql(desc = "Layer names to exclude.")] names: Vec<String>,
+    ) -> GqlGraph {
         let self_clone = self.clone();
         blocking_compute(move || self_clone.apply(|g| g.exclude_valid_layers(names.clone()))).await
     }
 
-    /// Returns a view containing the layer specified.
-    async fn layer(&self, name: String) -> GqlGraph {
+    /// View restricted to a single layer. Convenience form of
+    /// `layers(names: [name])` — updates on any other layer are hidden, and
+    /// entities with nothing left disappear.
+
+    async fn layer(&self, #[graphql(desc = "Layer name to include.")] name: String) -> GqlGraph {
         self.apply(|g| g.valid_layers(name.clone()))
     }
 
-    /// Returns a view containing all layers except the specified excluded layer.
-    async fn exclude_layer(&self, name: String) -> GqlGraph {
+    /// View with one layer hidden. Convenience form of
+    /// `excludeLayers(names: [name])` — updates on that layer are removed, and
+    /// entities with nothing left disappear.
+
+    async fn exclude_layer(
+        &self,
+        #[graphql(desc = "Layer name to exclude.")] name: String,
+    ) -> GqlGraph {
         self.apply(|g| g.exclude_valid_layers(name.clone()))
     }
 
-    /// Returns a subgraph of a specified set of nodes which contains only the edges that connect nodes of the subgraph to each other.
-    async fn subgraph(&self, nodes: Vec<String>) -> GqlGraph {
+    /// View restricted to a chosen set of nodes and the edges between them. Edges
+    /// connecting a selected node to a non-selected node are hidden.
+
+    async fn subgraph(
+        &self,
+        #[graphql(desc = "Node ids to keep.")] nodes: Vec<GqlNodeId>,
+    ) -> GqlGraph {
         let self_clone = self.clone();
         blocking_compute(move || self_clone.apply(|g| g.subgraph(nodes.clone()))).await
     }
 
-    /// Returns a view of the graph that only includes valid edges.
+    /// View containing only valid edges — for persistent graphs this drops edges
+    /// whose most recent event is a deletion at the latest time of the current
+    /// view (a later re-addition would keep them). On event graphs this is a
+    /// no-op.
     async fn valid(&self) -> GqlGraph {
         self.apply(|g| g.valid())
     }
 
-    /// Returns a subgraph filtered by the specified node types.
-    async fn subgraph_node_types(&self, node_types: Vec<String>) -> GqlGraph {
+    /// View restricted to nodes with the given node types.
+
+    async fn subgraph_node_types(
+        &self,
+        #[graphql(desc = "Node types to include.")] node_types: Vec<String>,
+    ) -> GqlGraph {
         let self_clone = self.clone();
         blocking_compute(move || self_clone.apply(|g| g.subgraph_node_types(node_types.clone())))
             .await
     }
 
-    /// Returns a subgraph containing all nodes except the specified excluded nodes.
-    async fn exclude_nodes(&self, nodes: Vec<String>) -> GqlGraph {
+    /// View with a set of nodes removed (along with any edges touching them).
+
+    async fn exclude_nodes(
+        &self,
+        #[graphql(desc = "Node ids to exclude.")] nodes: Vec<GqlNodeId>,
+    ) -> GqlGraph {
         let self_clone = self.clone();
         blocking_compute(move || {
             let nodes: Vec<NodeRef> = nodes.iter().map(|v| v.as_node_ref()).collect();
@@ -156,10 +213,20 @@ impl GqlGraph {
     /// e.g. "1 month and 1 day" will align at the start of the day.
     /// Note that passing a step larger than window while alignment_unit is not "Unaligned" may lead to some entries appearing before
     /// the start of the first window and/or after the end of the last window (i.e. not included in any window).
+
     async fn rolling(
         &self,
+        #[graphql(
+            desc = "Width of each window. Pass either `{epoch: <ms>}` for a discrete number of milliseconds (e.g. `{epoch: 1000}` for 1 second), or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}` or `{duration: 2 hours and 30 minutes}`)."
+        )]
         window: WindowDuration,
+        #[graphql(
+            desc = "Optional gap between the start of one window and the start of the next. Accepts the same `{epoch: <ms>}` or `{duration: <text>}` values as `window`. Defaults to `window` — i.e. windows touch end-to-end with no overlap and no gap."
+        )]
         step: Option<WindowDuration>,
+        #[graphql(
+            desc = "Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step` (or `window` if no step is set)."
+        )]
         alignment_unit: Option<GqlAlignmentUnit>,
     ) -> Result<GqlGraphWindowSet, GraphError> {
         let window = window.try_into_interval()?;
@@ -179,9 +246,16 @@ impl GqlGraph {
     /// alignment_unit optionally aligns the windows to the specified unit. "Unaligned" can be passed for no alignment.
     /// If unspecified (i.e. by default), alignment is done on the smallest unit of time in the step.
     /// e.g. "1 month and 1 day" will align at the start of the day.
+
     async fn expanding(
         &self,
+        #[graphql(
+            desc = "How much the window grows by on each step. Pass either `{epoch: <ms>}` for a discrete number of milliseconds, or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}`)."
+        )]
         step: WindowDuration,
+        #[graphql(
+            desc = "Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step`."
+        )]
         alignment_unit: Option<GqlAlignmentUnit>,
     ) -> Result<GqlGraphWindowSet, GraphError> {
         let step = step.try_into_interval()?;
@@ -194,14 +268,23 @@ impl GqlGraph {
     }
 
     /// Return a graph containing only the activity between start and end, by default raphtory stores times in milliseconds from the unix epoch.
-    async fn window(&self, start: GqlTimeInput, end: GqlTimeInput) -> GqlGraph {
+
+    async fn window(
+        &self,
+        #[graphql(desc = "Inclusive lower bound.")] start: GqlTimeInput,
+        #[graphql(desc = "Exclusive upper bound.")] end: GqlTimeInput,
+    ) -> GqlGraph {
         let start = start.into_time();
         let end = end.into_time();
         self.apply(|g| g.window(start, end))
     }
 
     /// Creates a view including all events at a specified time.
-    async fn at(&self, time: GqlTimeInput) -> GqlGraph {
+
+    async fn at(
+        &self,
+        #[graphql(desc = "Instant to pin the view to.")] time: GqlTimeInput,
+    ) -> GqlGraph {
         let time = time.into_time();
         self.apply(|g| g.at(time))
     }
@@ -213,7 +296,11 @@ impl GqlGraph {
     }
 
     /// Create a view including all events that are valid at the specified time.
-    async fn snapshot_at(&self, time: GqlTimeInput) -> GqlGraph {
+
+    async fn snapshot_at(
+        &self,
+        #[graphql(desc = "Instant at which entities must be valid.")] time: GqlTimeInput,
+    ) -> GqlGraph {
         let time = time.into_time();
         self.apply(|g| g.snapshot_at(time))
     }
@@ -224,32 +311,62 @@ impl GqlGraph {
     }
 
     /// Create a view including all events before a specified end (exclusive).
-    async fn before(&self, time: GqlTimeInput) -> GqlGraph {
+
+    async fn before(
+        &self,
+        #[graphql(desc = "Exclusive upper bound.")] time: GqlTimeInput,
+    ) -> GqlGraph {
         let time = time.into_time();
         self.apply(|g| g.before(time))
     }
 
     /// Create a view including all events after a specified start (exclusive).
-    async fn after(&self, time: GqlTimeInput) -> GqlGraph {
+
+    async fn after(
+        &self,
+        #[graphql(desc = "Exclusive lower bound.")] time: GqlTimeInput,
+    ) -> GqlGraph {
         let time = time.into_time();
         self.apply(|g| g.after(time))
     }
 
-    /// Shrink both the start and end of the window.
-    async fn shrink_window(&self, start: GqlTimeInput, end: GqlTimeInput) -> Self {
+    /// Shrink both the start and end of the window. The new bounds are taken as the
+    /// intersection with the current window; this never widens the view.
+
+    async fn shrink_window(
+        &self,
+        #[graphql(desc = "Proposed new start (TimeInput); ignored if before the current start.")]
+        start: GqlTimeInput,
+        #[graphql(desc = "Proposed new end (TimeInput); ignored if after the current end.")]
+        end: GqlTimeInput,
+    ) -> Self {
         let start = start.into_time();
         let end = end.into_time();
         self.apply(|g| g.shrink_window(start, end))
     }
 
     /// Set the start of the window to the larger of the specified value or current start.
-    async fn shrink_start(&self, start: GqlTimeInput) -> Self {
+
+    async fn shrink_start(
+        &self,
+        #[graphql(
+            desc = "Proposed new start (TimeInput); has no effect if it would widen the window."
+        )]
+        start: GqlTimeInput,
+    ) -> Self {
         let start = start.into_time();
         self.apply(|g| g.shrink_start(start))
     }
 
     /// Set the end of the window to the smaller of the specified value or current end.
-    async fn shrink_end(&self, end: GqlTimeInput) -> Self {
+
+    async fn shrink_end(
+        &self,
+        #[graphql(
+            desc = "Proposed new end (TimeInput); has no effect if it would widen the window."
+        )]
+        end: GqlTimeInput,
+    ) -> Self {
         let end = end.into_time();
         self.apply(|g| g.shrink_end(end))
     }
@@ -258,78 +375,93 @@ impl GqlGraph {
     //// TIME QUERIES //////
     ////////////////////////
 
-    /// Returns the timestamp for the creation of the graph.
-    async fn created(&self) -> Result<i64, GraphError> {
-        self.path.created_async().await
+    /// Filesystem creation timestamp (epoch millis) of the graph's on-disk folder
+    /// — i.e. when this graph was first saved to the server, not when its earliest
+    /// event occurred. Use `earliestTime` for the latter.
+    async fn created(&self) -> Result<i64> {
+        Ok(self.path.created_async().await?)
     }
 
     /// Returns the graph's last opened timestamp according to system time.
-    async fn last_opened(&self) -> Result<i64, GraphError> {
-        self.path.last_opened_async().await
+    async fn last_opened(&self) -> Result<i64> {
+        Ok(self.path.last_opened_async().await?)
     }
 
     /// Returns the graph's last updated timestamp.
-    async fn last_updated(&self) -> Result<i64, GraphError> {
-        self.path.last_updated_async().await
+    async fn last_updated(&self) -> Result<i64> {
+        Ok(self.path.last_updated_async().await?)
     }
 
     /// Returns the time entry of the earliest activity in the graph.
-    async fn earliest_time(&self) -> GqlEventTime {
+    async fn earliest_time(&self) -> Result<GqlEventTime> {
         let self_clone = self.clone();
-        blocking_compute(move || self_clone.graph.earliest_time().into()).await
+        Ok(blocking_compute(move || self_clone.graph.earliest_time().into()).await)
     }
 
     /// Returns the time entry of the latest activity in the graph.
-    async fn latest_time(&self) -> GqlEventTime {
+    async fn latest_time(&self) -> Result<GqlEventTime> {
         let self_clone = self.clone();
-        blocking_compute(move || self_clone.graph.latest_time().into()).await
+        Ok(blocking_compute(move || self_clone.graph.latest_time().into()).await)
     }
 
     /// Returns the start time of the window. Errors if there is no window.
-    async fn start(&self) -> GqlEventTime {
-        self.graph.start().into()
+    async fn start(&self) -> Result<GqlEventTime> {
+        Ok(self.graph.start().into())
     }
 
     /// Returns the end time of the window. Errors if there is no window.
-    async fn end(&self) -> GqlEventTime {
-        self.graph.end().into()
+    async fn end(&self) -> Result<GqlEventTime> {
+        Ok(self.graph.end().into())
     }
 
-    /// Returns the earliest time that any edge in this graph is valid.
-    async fn earliest_edge_time(&self, include_negative: Option<bool>) -> GqlEventTime {
+    /// The earliest time at which any edge in this graph is valid.
+    ///
+    /// * `includeNegative` — if false, edge events with a timestamp `< 0` are
+    ///   skipped when computing the minimum. Defaults to true.
+    async fn earliest_edge_time(
+        &self,
+        #[graphql(
+            desc = "If false, edge events with a timestamp `< 0` are skipped when computing the minimum. Defaults to true."
+        )]
+        include_negative: Option<bool>,
+    ) -> Result<GqlEventTime> {
         let self_clone = self.clone();
-        blocking_compute(move || {
+        Ok(blocking_compute(move || {
             let include_negative = include_negative.unwrap_or(true);
-            let all_edges = self_clone
+            self_clone
                 .graph
                 .edges()
                 .earliest_time()
                 .into_iter()
                 .filter_map(|edge_time| edge_time.filter(|&time| include_negative || time.t() >= 0))
                 .min()
-                .into();
-            all_edges
+                .into()
         })
-        .await
+        .await)
     }
 
-    /// Returns the latest time that any edge in this graph is valid.
-    async fn latest_edge_time(&self, include_negative: Option<bool>) -> GqlEventTime {
+    /// The latest time at which any edge in this graph is valid.
+
+    async fn latest_edge_time(
+        &self,
+        #[graphql(
+            desc = "If false, edge events with a timestamp `< 0` are skipped when computing the maximum. Defaults to true."
+        )]
+        include_negative: Option<bool>,
+    ) -> Result<GqlEventTime> {
         let self_clone = self.clone();
-        blocking_compute(move || {
+        Ok(blocking_compute(move || {
             let include_negative = include_negative.unwrap_or(true);
-            let all_edges = self_clone
+            self_clone
                 .graph
                 .edges()
                 .latest_time()
                 .into_iter()
                 .filter_map(|edge_time| edge_time.filter(|&time| include_negative || time.t() >= 0))
                 .max()
-                .into();
-
-            all_edges
+                .into()
         })
-        .await
+        .await)
     }
 
     ////////////////////////
@@ -363,34 +495,57 @@ impl GqlGraph {
     //// EXISTS CHECKERS ///
     ////////////////////////
 
-    /// Returns true if the graph contains the specified node.
-    async fn has_node(&self, name: String) -> bool {
-        self.graph.has_node(name)
+    /// Returns true if a node with the given id exists in this view.
+
+    async fn has_node(
+        &self,
+        #[graphql(desc = "Node id to look up.")] name: GqlNodeId,
+    ) -> Result<bool> {
+        Ok(self.graph.has_node(name))
     }
 
-    /// Returns true if the graph contains the specified edge. Edges are specified by providing a source and destination node id. You can restrict the search to a specified layer.
-    async fn has_edge(&self, src: String, dst: String, layer: Option<String>) -> bool {
-        match layer {
+    /// Returns true if an edge exists between `src` and `dst` in this view, optionally
+    /// restricted to a single layer.
+
+    async fn has_edge(
+        &self,
+        #[graphql(desc = "Source node id.")] src: GqlNodeId,
+        #[graphql(desc = "Destination node id.")] dst: GqlNodeId,
+        #[graphql(
+            desc = "Optional; if provided, only checks whether the edge exists on this layer. If null or omitted, any layer counts."
+        )]
+        layer: Option<String>,
+    ) -> Result<bool> {
+        Ok(match layer {
             Some(name) => self
                 .graph
                 .layers(name)
                 .map(|l| l.has_edge(src, dst))
                 .unwrap_or(false),
             None => self.graph.has_edge(src, dst),
-        }
+        })
     }
 
     ////////////////////////
     //////// GETTERS ///////
     ////////////////////////
 
-    /// Gets the node with the specified id.
-    async fn node(&self, name: String) -> Option<GqlNode> {
-        self.graph.node(name).map(|node| node.into())
+    /// Look up a single node by id. Returns null if the node doesn't exist in this
+    /// view.
+
+    async fn node(&self, #[graphql(desc = "Node id.")] name: GqlNodeId) -> Result<Option<GqlNode>> {
+        Ok(self.graph.node(name).map(|node| node.into()))
     }
 
-    /// Gets (optionally a subset of) the nodes in the graph.
-    async fn nodes(&self, select: Option<GqlNodeFilter>) -> Result<GqlNodes, GraphError> {
+    /// All nodes in this view, optionally narrowed by a filter.
+
+    async fn nodes(
+        &self,
+        #[graphql(
+            desc = "Optional node filter (by name, property, type, etc.). If omitted, every node in the view is returned."
+        )]
+        select: Option<GqlNodeFilter>,
+    ) -> Result<GqlNodes> {
         let nn = self.graph.nodes();
 
         if let Some(sel) = select {
@@ -406,13 +561,26 @@ impl GqlGraph {
         Ok(GqlNodes::new(nn))
     }
 
-    /// Gets the edge with the specified source and destination nodes.
-    async fn edge(&self, src: String, dst: String) -> Option<GqlEdge> {
-        self.graph.edge(src, dst).map(|e| e.into())
+    /// Look up a single edge by its endpoint ids. Returns null if no edge exists
+    /// between `src` and `dst` in this view.
+
+    async fn edge(
+        &self,
+        #[graphql(desc = "Source node id.")] src: GqlNodeId,
+        #[graphql(desc = "Destination node id.")] dst: GqlNodeId,
+    ) -> Result<Option<GqlEdge>> {
+        Ok(self.graph.edge(src, dst).map(|e| e.into()))
     }
 
-    /// Gets the edges in the graph.
-    async fn edges<'a>(&self, select: Option<GqlEdgeFilter>) -> Result<GqlEdges, GraphError> {
+    /// All edges in this view, optionally narrowed by a filter.
+
+    async fn edges<'a>(
+        &self,
+        #[graphql(
+            desc = "Optional edge filter (by property, layer, src/dst, etc.). If omitted, every edge in the view is returned."
+        )]
+        select: Option<GqlEdgeFilter>,
+    ) -> Result<GqlEdges> {
         let base = self.graph.edges_unlocked();
 
         if let Some(sel) = select {
@@ -429,13 +597,13 @@ impl GqlGraph {
     ////////////////////////
 
     /// Returns the properties of the graph.
-    async fn properties(&self) -> GqlProperties {
-        Into::<DynProperties>::into(self.graph.properties()).into()
+    async fn properties(&self) -> Result<GqlProperties> {
+        Ok(Into::<DynProperties>::into(self.graph.properties()).into())
     }
 
     /// Returns the metadata of the graph.
-    async fn metadata(&self) -> GqlMetadata {
-        self.graph.metadata().into()
+    async fn metadata(&self) -> Result<GqlMetadata> {
+        Ok(self.graph.metadata().into())
     }
 
     ////////////////////////
@@ -446,48 +614,49 @@ impl GqlGraph {
     //if someone write non-utf characters as a filename
 
     /// Returns the graph name.
-    async fn name(&self) -> Result<String, GraphError> {
+    async fn name(&self) -> Result<String, PathValidationError> {
         self.path.get_graph_name()
     }
 
     /// Returns path of graph.
-    async fn path(&self) -> Result<String, GraphError> {
-        Ok(self
-            .path
-            .get_original_path()
-            .to_str()
-            .ok_or(InvalidPathReason::PathNotParsable(
-                self.path.to_error_path(),
-            ))?
-            .to_owned())
+    async fn path(&self) -> String {
+        self.path.local_path().into()
     }
 
     /// Returns namespace of graph.
-    async fn namespace(&self) -> Result<String, GraphError> {
-        Ok(self
-            .path
-            .get_original_path()
-            .parent()
-            .and_then(|p| p.to_str().map(|s| s.to_string()))
-            .ok_or(InvalidPathReason::PathNotParsable(
-                self.path.to_error_path(),
-            ))?
-            .to_owned())
+    async fn namespace(&self) -> String {
+        self.path
+            .local_path()
+            .rsplit_once("/")
+            .map_or("", |(prefix, _)| prefix)
+            .to_string()
     }
 
     /// Returns the graph schema.
-    async fn schema(&self) -> GraphSchema {
+    async fn schema(&self) -> Result<GraphSchema> {
         let self_clone = self.clone();
-        blocking_compute(move || GraphSchema::new(&self_clone.graph)).await
+        Ok(blocking_compute(move || GraphSchema::new(&self_clone.graph)).await)
     }
 
+    /// Access registered graph algorithms (PageRank, shortest path, etc.) for this
+    /// graph view. The set of available algorithms is defined by the plugin registry
+    /// loaded at server startup.
     async fn algorithms(&self) -> GraphAlgorithmPlugin {
         self.graph.clone().into()
     }
 
-    async fn shared_neighbours(&self, selected_nodes: Vec<String>) -> Vec<GqlNode> {
+    /// Nodes that are neighbours of every node in `selectedNodes`. Returns the
+    /// intersection of each selected node's neighbour set (undirected).
+
+    async fn shared_neighbours(
+        &self,
+        #[graphql(
+            desc = "Node ids whose common neighbours you want. Returns an empty list if `selectedNodes` is empty or any id does not exist."
+        )]
+        selected_nodes: Vec<GqlNodeId>,
+    ) -> Result<Vec<GqlNode>> {
         let self_clone = self.clone();
-        blocking_compute(move || {
+        Ok(blocking_compute(move || {
             if selected_nodes.is_empty() {
                 return vec![];
             }
@@ -513,28 +682,39 @@ impl GqlGraph {
                 None => vec![],
             }
         })
-        .await
+        .await)
     }
 
-    /// Export all nodes and edges from this graph view to another existing graph
+    /// Copy all nodes and edges of the current graph view into another already-
+    /// existing graph stored on the server. The destination graph is preserved
+    /// — this only adds; it does not replace.
+
     async fn export_to<'a>(
         &self,
         ctx: &Context<'a>,
-        path: String,
-    ) -> Result<bool, Arc<GraphError>> {
+        #[graphql(desc = "Destination graph path relative to the root namespace.")] path: String,
+    ) -> Result<bool> {
         let data = ctx.data_unchecked::<Data>();
-        let other_g = data.get_graph(path.as_ref()).await?.0;
+        let other_g = data.get_graph(path.as_ref()).await?.graph;
         let g = self.graph.clone();
         blocking_compute(move || {
             other_g.import_nodes(g.nodes(), true)?;
             other_g.import_edges(g.edges(), true)?;
-            other_g.write_updates()?;
             Ok(true)
         })
         .await
     }
 
-    async fn filter(&self, expr: Option<GqlGraphFilter>) -> Result<Self, GraphError> {
+    /// Returns a filtered view of the graph. Applies a mixed node/edge filter
+    /// expression and narrows nodes, edges, and their properties to what matches.
+
+    async fn filter(
+        &self,
+        #[graphql(
+            desc = "Optional composite filter combining node, edge, property, and metadata conditions. If omitted, applies the identity filter (equivalent to no filtering)."
+        )]
+        expr: Option<GqlGraphFilter>,
+    ) -> Result<Self, GraphError> {
         let self_clone = self.clone();
         blocking_compute(move || {
             let filter: DynView = match expr {
@@ -550,7 +730,14 @@ impl GqlGraph {
         .await
     }
 
-    async fn filter_nodes(&self, expr: GqlNodeFilter) -> Result<Self, GraphError> {
+    /// Returns a graph view restricted to nodes that match the given filter; edges
+    /// are kept only if both endpoints survive.
+
+    async fn filter_nodes(
+        &self,
+        #[graphql(desc = "Composite node filter (by name, property, type, etc.).")]
+        expr: GqlNodeFilter,
+    ) -> Result<Self, GraphError> {
         let self_clone = self.clone();
         blocking_compute(move || {
             let filter: CompositeNodeFilter = expr.try_into()?;
@@ -563,7 +750,14 @@ impl GqlGraph {
         .await
     }
 
-    async fn filter_edges(&self, expr: GqlEdgeFilter) -> Result<Self, GraphError> {
+    /// Returns a graph view restricted to edges that match the given filter. Nodes
+    /// remain in the view even if all their edges are filtered out.
+
+    async fn filter_edges(
+        &self,
+        #[graphql(desc = "Composite edge filter (by property, layer, src/dst, etc.).")]
+        expr: GqlEdgeFilter,
+    ) -> Result<Self, GraphError> {
         let self_clone = self.clone();
         blocking_compute(move || {
             let filter: CompositeEdgeFilter = expr.try_into()?;
@@ -600,15 +794,17 @@ impl GqlGraph {
         }
     }
 
-    /// (Experimental) Searches for nodes which match the given filter expression.
-    ///
-    /// Uses Tantivy's exact search.
+    /// (Experimental) Searches for nodes which match the given filter
+    /// expression. Uses Tantivy's exact search; requires the graph to have
+    /// been indexed.
+
     async fn search_nodes(
         &self,
+        #[graphql(desc = "Composite node filter (by name, property, type, etc.).")]
         filter: GqlNodeFilter,
-        limit: usize,
-        offset: usize,
-    ) -> Result<Vec<GqlNode>, GraphError> {
+        #[graphql(desc = "Maximum number of nodes to return.")] limit: usize,
+        #[graphql(desc = "Number of matches to skip before returning results.")] offset: usize,
+    ) -> Result<Vec<GqlNode>> {
         #[cfg(feature = "search")]
         {
             let self_clone = self.clone();
@@ -626,15 +822,17 @@ impl GqlGraph {
         }
     }
 
-    /// (Experimental) Searches the index for edges which match the given filter expression.
-    ///
-    /// Uses Tantivy's exact search.
+    /// (Experimental) Searches the index for edges which match the given
+    /// filter expression. Uses Tantivy's exact search; requires the graph to
+    /// have been indexed.
+
     async fn search_edges(
         &self,
+        #[graphql(desc = "Composite edge filter (by property, layer, src/dst, etc.).")]
         filter: GqlEdgeFilter,
-        limit: usize,
-        offset: usize,
-    ) -> Result<Vec<GqlEdge>, GraphError> {
+        #[graphql(desc = "Maximum number of edges to return.")] limit: usize,
+        #[graphql(desc = "Number of matches to skip before returning results.")] offset: usize,
+    ) -> Result<Vec<GqlEdge>> {
         #[cfg(feature = "search")]
         {
             let self_clone = self.clone();
@@ -652,9 +850,17 @@ impl GqlGraph {
         }
     }
 
-    /// Returns the specified graph view or if none is specified returns the default view.
-    /// This allows you to specify multiple operations together.
-    async fn apply_views(&self, views: Vec<GraphViewCollection>) -> Result<GqlGraph, GraphError> {
+    /// Apply a list of view operations in the given order and return the
+    /// resulting graph view. Lets callers compose multiple view transforms
+    /// (window, layer, filter, snapshot, ...) in a single call.
+
+    async fn apply_views(
+        &self,
+        #[graphql(
+            desc = "Ordered list of view operations; each entry is a one-of variant applied to the running result."
+        )]
+        views: Vec<GraphViewCollection>,
+    ) -> Result<GqlGraph, GraphError> {
         let mut return_view: GqlGraph = GqlGraph::new(self.path.clone(), self.graph.clone());
         for view in views {
             return_view = match view {
diff --git a/raphtory-graphql/src/model/graph/history.rs b/raphtory-graphql/src/model/graph/history.rs
index 58c15c34d3..fbb629da22 100644
--- a/raphtory-graphql/src/model/graph/history.rs
+++ b/raphtory-graphql/src/model/graph/history.rs
@@ -1,8 +1,11 @@
 use crate::{
-    model::graph::timeindex::{dt_format_str_is_valid, GqlEventTime},
+    model::graph::{
+        collection::{check_list_allowed, check_page_limit},
+        timeindex::{dt_format_str_is_valid, GqlEventTime},
+    },
     rayon::blocking_compute,
 };
-use async_graphql::Error;
+use async_graphql::{Context, Error};
 use dynamic_graphql::{ResolvedObject, ResolvedObjectFields};
 use raphtory::db::api::view::history::{
     History, HistoryDateTime, HistoryEventId, HistoryTimestamp, InternalHistoryOps, Intervals,
@@ -50,15 +53,20 @@ impl GqlHistory {
     }
 
     /// List all time entries present in this history.
-    async fn list(&self) -> Vec<GqlEventTime> {
+    async fn list(&self, ctx: &Context<'_>) -> async_graphql::Result<Vec<GqlEventTime>> {
+        check_list_allowed(ctx)?;
         let self_clone = self.clone();
-        blocking_compute(move || self_clone.history.iter().map(|t| t.into()).collect()).await
+        Ok(blocking_compute(move || self_clone.history.iter().map(|t| t.into()).collect()).await)
     }
 
     /// List all time entries present in this history in reverse order.
-    async fn list_rev(&self) -> Vec<GqlEventTime> {
+    async fn list_rev(&self, ctx: &Context<'_>) -> async_graphql::Result<Vec<GqlEventTime>> {
+        check_list_allowed(ctx)?;
         let self_clone = self.clone();
-        blocking_compute(move || self_clone.history.iter_rev().map(|t| t.into()).collect()).await
+        Ok(
+            blocking_compute(move || self_clone.history.iter_rev().map(|t| t.into()).collect())
+                .await,
+        )
     }
 
     /// Fetch one page of EventTime entries with a number of items up to a specified limit,
@@ -66,14 +74,21 @@ impl GqlHistory {
     ///
     /// For example, if page(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
     /// will be returned.
+
     async fn page(
         &self,
-        limit: usize,
+        ctx: &Context<'_>,
+        #[graphql(desc = "Maximum number of items to return on this page.")] limit: usize,
+        #[graphql(desc = "Extra items to skip on top of `pageIndex` paging (default 0).")]
         offset: Option<usize>,
+        #[graphql(
+            desc = "Zero-based page number; multiplies `limit` to determine where to start (default 0)."
+        )]
         page_index: Option<usize>,
-    ) -> Vec<GqlEventTime> {
+    ) -> async_graphql::Result<Vec<GqlEventTime>> {
+        check_page_limit(ctx, limit)?;
         let self_clone = self.clone();
-        blocking_compute(move || {
+        Ok(blocking_compute(move || {
             let start = page_index.unwrap_or(0) * limit + offset.unwrap_or(0);
             self_clone
                 .history
@@ -83,7 +98,7 @@ impl GqlHistory {
                 .map(|t| t.into())
                 .collect()
         })
-        .await
+        .await)
     }
 
     /// Fetch one page of EventTime entries with a number of items up to a specified limit,
@@ -91,14 +106,21 @@ impl GqlHistory {
     ///
     /// For example, if page_rev(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
     /// will be returned.
+
     async fn page_rev(
         &self,
-        limit: usize,
+        ctx: &Context<'_>,
+        #[graphql(desc = "Maximum number of items to return on this page.")] limit: usize,
+        #[graphql(desc = "Extra items to skip on top of `pageIndex` paging (default 0).")]
         offset: Option<usize>,
+        #[graphql(
+            desc = "Zero-based page number; multiplies `limit` to determine where to start (default 0)."
+        )]
         page_index: Option<usize>,
-    ) -> Vec<GqlEventTime> {
+    ) -> async_graphql::Result<Vec<GqlEventTime>> {
+        check_page_limit(ctx, limit)?;
         let self_clone = self.clone();
-        blocking_compute(move || {
+        Ok(blocking_compute(move || {
             let start = page_index.unwrap_or(0) * limit + offset.unwrap_or(0);
             self_clone
                 .history
@@ -108,7 +130,7 @@ impl GqlHistory {
                 .map(|t| t.into())
                 .collect()
         })
-        .await
+        .await)
     }
 
     /// Returns True if the history is empty.
@@ -137,7 +159,14 @@ impl GqlHistory {
     /// Useful for converting millisecond timestamps into easily readable datetime strings.
     /// Optionally, a format string can be passed to format the output. Defaults to RFC 3339 if not provided (e.g., "2023-12-25T10:30:45.123Z").
     /// Refer to chrono::format::strftime for formatting specifiers and escape sequences.
-    async fn datetimes(&self, format_string: Option<String>) -> GqlHistoryDateTime {
+
+    async fn datetimes(
+        &self,
+        #[graphql(
+            desc = "Optional format string for the rendered datetime. Uses `%`-style specifiers — for example `%Y-%m-%d` for `2024-01-15`, `%Y-%m-%d %H:%M:%S` for `2024-01-15 10:30:00`, or `%H:%M` for `10:30`. Defaults to RFC 3339 (e.g. `2024-01-15T10:30:45.123+00:00`) when omitted."
+        )]
+        format_string: Option<String>,
+    ) -> GqlHistoryDateTime {
         let self_clone = self.clone();
         blocking_compute(move || GqlHistoryDateTime {
             history_dt: HistoryDateTime::new(self_clone.history.0.clone()), // clone the Arc, not the underlying object
@@ -156,7 +185,10 @@ impl GqlHistory {
         .await
     }
 
-    /// Returns an Intervals object which calculates the intervals between consecutive EventTime timestamps.
+    /// Inter-event gap analysis for this history. The returned `Intervals`
+    /// object exposes each gap (in milliseconds) between consecutive events,
+    /// plus summary statistics — `min` / `max` / `mean` / `median` — and
+    /// paginated access via `list` / `listRev` / `page` / `pageRev`.
     async fn intervals(&self) -> GqlIntervals {
         let self_clone = self.clone();
         blocking_compute(move || GqlIntervals {
@@ -176,15 +208,17 @@ pub struct GqlHistoryTimestamp {
 #[ResolvedObjectFields]
 impl GqlHistoryTimestamp {
     /// List all timestamps.
-    async fn list(&self) -> Vec<i64> {
+    async fn list(&self, ctx: &Context<'_>) -> async_graphql::Result<Vec<i64>> {
+        check_list_allowed(ctx)?;
         let self_clone = self.clone();
-        blocking_compute(move || self_clone.history_t.collect()).await
+        Ok(blocking_compute(move || self_clone.history_t.collect()).await)
     }
 
     /// List all timestamps in reverse order.
-    async fn list_rev(&self) -> Vec<i64> {
+    async fn list_rev(&self, ctx: &Context<'_>) -> async_graphql::Result<Vec<i64>> {
+        check_list_allowed(ctx)?;
         let self_clone = self.clone();
-        blocking_compute(move || self_clone.history_t.collect_rev()).await
+        Ok(blocking_compute(move || self_clone.history_t.collect_rev()).await)
     }
 
     /// Fetch one page of timestamps with a number of items up to a specified limit, optionally offset by a specified amount.
@@ -192,14 +226,21 @@ impl GqlHistoryTimestamp {
     ///
     /// For example, if page(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
     /// will be returned.
+
     async fn page(
         &self,
-        limit: usize,
+        ctx: &Context<'_>,
+        #[graphql(desc = "Maximum number of items to return on this page.")] limit: usize,
+        #[graphql(desc = "Extra items to skip on top of `pageIndex` paging (default 0).")]
         offset: Option<usize>,
+        #[graphql(
+            desc = "Zero-based page number; multiplies `limit` to determine where to start (default 0)."
+        )]
         page_index: Option<usize>,
-    ) -> Vec<i64> {
+    ) -> async_graphql::Result<Vec<i64>> {
+        check_page_limit(ctx, limit)?;
         let self_clone = self.clone();
-        blocking_compute(move || {
+        Ok(blocking_compute(move || {
             let start = page_index.unwrap_or(0) * limit + offset.unwrap_or(0);
             self_clone
                 .history_t
@@ -208,7 +249,7 @@ impl GqlHistoryTimestamp {
                 .take(limit)
                 .collect()
         })
-        .await
+        .await)
     }
 
     /// Fetch one page of timestamps in reverse order with a number of items up to a specified limit,
@@ -216,14 +257,21 @@ impl GqlHistoryTimestamp {
     ///
     /// For example, if page_rev(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
     /// will be returned.
+
     async fn page_rev(
         &self,
-        limit: usize,
+        ctx: &Context<'_>,
+        #[graphql(desc = "Maximum number of items to return on this page.")] limit: usize,
+        #[graphql(desc = "Extra items to skip on top of `pageIndex` paging (default 0).")]
         offset: Option<usize>,
+        #[graphql(
+            desc = "Zero-based page number; multiplies `limit` to determine where to start (default 0)."
+        )]
         page_index: Option<usize>,
-    ) -> Vec<i64> {
+    ) -> async_graphql::Result<Vec<i64>> {
+        check_page_limit(ctx, limit)?;
         let self_clone = self.clone();
-        blocking_compute(move || {
+        Ok(blocking_compute(move || {
             let start = page_index.unwrap_or(0) * limit + offset.unwrap_or(0);
             self_clone
                 .history_t
@@ -232,7 +280,7 @@ impl GqlHistoryTimestamp {
                 .take(limit)
                 .collect()
         })
-        .await
+        .await)
     }
 }
 
@@ -249,7 +297,16 @@ impl GqlHistoryDateTime {
     /// List all datetimes formatted as strings.
     /// If filter_broken is set to True, time conversion errors will be ignored. If set to False, a TimeError
     /// will be raised on time conversion error. Defaults to False.
-    async fn list(&self, filter_broken: Option<bool>) -> Result<Vec<String>, Error> {
+
+    async fn list(
+        &self,
+        ctx: &Context<'_>,
+        #[graphql(
+            desc = "If true, ignore unconvertible timestamps; if false, raise an error on the first conversion failure. Defaults to false."
+        )]
+        filter_broken: Option<bool>,
+    ) -> Result<Vec<String>, Error> {
+        check_list_allowed(ctx)?;
         let self_clone = self.clone();
         blocking_compute(move || {
             let fmt_string = self_clone.format_string.as_deref().unwrap_or("%+"); // %+ is RFC 3339
@@ -280,7 +337,16 @@ impl GqlHistoryDateTime {
     /// List all datetimes formatted as strings in reverse chronological order.
     /// If filter_broken is set to True, time conversion errors will be ignored. If set to False, a TimeError
     /// will be raised on time conversion error. Defaults to False.
-    async fn list_rev(&self, filter_broken: Option<bool>) -> Result<Vec<String>, Error> {
+
+    async fn list_rev(
+        &self,
+        ctx: &Context<'_>,
+        #[graphql(
+            desc = "If true, ignore unconvertible timestamps; if false, raise an error on the first conversion failure. Defaults to false."
+        )]
+        filter_broken: Option<bool>,
+    ) -> Result<Vec<String>, Error> {
+        check_list_allowed(ctx)?;
         let self_clone = self.clone();
         blocking_compute(move || {
             let fmt_string = self_clone.format_string.as_deref().unwrap_or("%+"); // %+ is RFC 3339
@@ -315,13 +381,23 @@ impl GqlHistoryDateTime {
     ///
     /// For example, if page(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
     /// will be returned.
+
     async fn page(
         &self,
-        limit: usize,
+        ctx: &Context<'_>,
+        #[graphql(desc = "Maximum number of items to return on this page.")] limit: usize,
+        #[graphql(desc = "Extra items to skip on top of `pageIndex` paging (default 0).")]
         offset: Option<usize>,
+        #[graphql(
+            desc = "Zero-based page number; multiplies `limit` to determine where to start (default 0)."
+        )]
         page_index: Option<usize>,
+        #[graphql(
+            desc = "If true, skip timestamps whose conversion fails; if false, raise an error on the first conversion failure. Defaults to false."
+        )]
         filter_broken: Option<bool>,
     ) -> Result<Vec<String>, Error> {
+        check_page_limit(ctx, limit)?;
         let self_clone = self.clone();
         blocking_compute(move || {
             let start = page_index.unwrap_or(0) * limit + offset.unwrap_or(0);
@@ -360,13 +436,23 @@ impl GqlHistoryDateTime {
     ///
     /// For example, if page_rev(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
     /// will be returned.
+
     async fn page_rev(
         &self,
-        limit: usize,
+        ctx: &Context<'_>,
+        #[graphql(desc = "Maximum number of items to return on this page.")] limit: usize,
+        #[graphql(desc = "Extra items to skip on top of `pageIndex` paging (default 0).")]
         offset: Option<usize>,
+        #[graphql(
+            desc = "Zero-based page number; multiplies `limit` to determine where to start (default 0)."
+        )]
         page_index: Option<usize>,
+        #[graphql(
+            desc = "If true, skip timestamps whose conversion fails; if false, raise an error on the first conversion failure. Defaults to false."
+        )]
         filter_broken: Option<bool>,
     ) -> Result<Vec<String>, Error> {
+        check_page_limit(ctx, limit)?;
         let self_clone = self.clone();
         blocking_compute(move || {
             let start = page_index.unwrap_or(0) * limit + offset.unwrap_or(0);
@@ -409,29 +495,31 @@ pub struct GqlHistoryEventId {
 #[ResolvedObjectFields]
 impl GqlHistoryEventId {
     /// List event ids.
-    async fn list(&self) -> Vec<u64> {
+    async fn list(&self, ctx: &Context<'_>) -> async_graphql::Result<Vec<u64>> {
+        check_list_allowed(ctx)?;
         let self_clone = self.clone();
-        blocking_compute(move || {
+        Ok(blocking_compute(move || {
             self_clone
                 .history_s
                 .iter()
                 .map(|s: usize| s as u64)
                 .collect()
         })
-        .await
+        .await)
     }
 
     /// List event ids in reverse order.
-    async fn list_rev(&self) -> Vec<u64> {
+    async fn list_rev(&self, ctx: &Context<'_>) -> async_graphql::Result<Vec<u64>> {
+        check_list_allowed(ctx)?;
         let self_clone = self.clone();
-        blocking_compute(move || {
+        Ok(blocking_compute(move || {
             self_clone
                 .history_s
                 .iter_rev()
                 .map(|s: usize| s as u64)
                 .collect()
         })
-        .await
+        .await)
     }
 
     /// Fetch one page of event ids with a number of items up to a specified limit,
@@ -439,14 +527,21 @@ impl GqlHistoryEventId {
     ///
     /// For example, if page(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
     /// will be returned.
+
     async fn page(
         &self,
-        limit: usize,
+        ctx: &Context<'_>,
+        #[graphql(desc = "Maximum number of items to return on this page.")] limit: usize,
+        #[graphql(desc = "Extra items to skip on top of `pageIndex` paging (default 0).")]
         offset: Option<usize>,
+        #[graphql(
+            desc = "Zero-based page number; multiplies `limit` to determine where to start (default 0)."
+        )]
         page_index: Option<usize>,
-    ) -> Vec<u64> {
+    ) -> async_graphql::Result<Vec<u64>> {
+        check_page_limit(ctx, limit)?;
         let self_clone = self.clone();
-        blocking_compute(move || {
+        Ok(blocking_compute(move || {
             let start = page_index.unwrap_or(0) * limit + offset.unwrap_or(0);
             self_clone
                 .history_s
@@ -456,7 +551,7 @@ impl GqlHistoryEventId {
                 .map(|s: usize| s as u64)
                 .collect()
         })
-        .await
+        .await)
     }
 
     /// Fetch one page of event ids in reverse chronological order with a number of items up to a specified limit,
@@ -464,14 +559,21 @@ impl GqlHistoryEventId {
     ///
     /// For example, if page_rev(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
     /// will be returned.
+
     async fn page_rev(
         &self,
-        limit: usize,
+        ctx: &Context<'_>,
+        #[graphql(desc = "Maximum number of items to return on this page.")] limit: usize,
+        #[graphql(desc = "Extra items to skip on top of `pageIndex` paging (default 0).")]
         offset: Option<usize>,
+        #[graphql(
+            desc = "Zero-based page number; multiplies `limit` to determine where to start (default 0)."
+        )]
         page_index: Option<usize>,
-    ) -> Vec<u64> {
+    ) -> async_graphql::Result<Vec<u64>> {
+        check_page_limit(ctx, limit)?;
         let self_clone = self.clone();
-        blocking_compute(move || {
+        Ok(blocking_compute(move || {
             let start = page_index.unwrap_or(0) * limit + offset.unwrap_or(0);
             self_clone
                 .history_s
@@ -481,7 +583,7 @@ impl GqlHistoryEventId {
                 .map(|s: usize| s as u64)
                 .collect()
         })
-        .await
+        .await)
     }
 }
 
@@ -495,15 +597,17 @@ pub struct GqlIntervals {
 #[ResolvedObjectFields]
 impl GqlIntervals {
     /// List time intervals between consecutive timestamps in milliseconds.
-    async fn list(&self) -> Vec<i64> {
+    async fn list(&self, ctx: &Context<'_>) -> async_graphql::Result<Vec<i64>> {
+        check_list_allowed(ctx)?;
         let self_clone = self.clone();
-        blocking_compute(move || self_clone.intervals.collect()).await
+        Ok(blocking_compute(move || self_clone.intervals.collect()).await)
     }
 
     /// List millisecond time intervals between consecutive timestamps in reverse order.
-    async fn list_rev(&self) -> Vec<i64> {
+    async fn list_rev(&self, ctx: &Context<'_>) -> async_graphql::Result<Vec<i64>> {
+        check_list_allowed(ctx)?;
         let self_clone = self.clone();
-        blocking_compute(move || self_clone.intervals.collect_rev()).await
+        Ok(blocking_compute(move || self_clone.intervals.collect_rev()).await)
     }
 
     /// Fetch one page of intervals between consecutive timestamps with a number of items up to a specified limit,
@@ -511,14 +615,21 @@ impl GqlIntervals {
     ///
     /// For example, if page(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
     /// will be returned.
+
     async fn page(
         &self,
-        limit: usize,
+        ctx: &Context<'_>,
+        #[graphql(desc = "Maximum number of items to return on this page.")] limit: usize,
+        #[graphql(desc = "Extra items to skip on top of `pageIndex` paging (default 0).")]
         offset: Option<usize>,
+        #[graphql(
+            desc = "Zero-based page number; multiplies `limit` to determine where to start (default 0)."
+        )]
         page_index: Option<usize>,
-    ) -> Vec<i64> {
+    ) -> async_graphql::Result<Vec<i64>> {
+        check_page_limit(ctx, limit)?;
         let self_clone = self.clone();
-        blocking_compute(move || {
+        Ok(blocking_compute(move || {
             let start = page_index.unwrap_or(0) * limit + offset.unwrap_or(0);
             self_clone
                 .intervals
@@ -527,7 +638,7 @@ impl GqlIntervals {
                 .take(limit)
                 .collect()
         })
-        .await
+        .await)
     }
 
     /// Fetch one page of intervals between consecutive timestamps in reverse order with a number of items up to a specified limit,
@@ -535,14 +646,21 @@ impl GqlIntervals {
     ///
     /// For example, if page(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
     /// will be returned.
+
     async fn page_rev(
         &self,
-        limit: usize,
+        ctx: &Context<'_>,
+        #[graphql(desc = "Maximum number of items to return on this page.")] limit: usize,
+        #[graphql(desc = "Extra items to skip on top of `pageIndex` paging (default 0).")]
         offset: Option<usize>,
+        #[graphql(
+            desc = "Zero-based page number; multiplies `limit` to determine where to start (default 0)."
+        )]
         page_index: Option<usize>,
-    ) -> Vec<i64> {
+    ) -> async_graphql::Result<Vec<i64>> {
+        check_page_limit(ctx, limit)?;
         let self_clone = self.clone();
-        blocking_compute(move || {
+        Ok(blocking_compute(move || {
             let start = page_index.unwrap_or(0) * limit + offset.unwrap_or(0);
             self_clone
                 .intervals
@@ -551,7 +669,7 @@ impl GqlIntervals {
                 .take(limit)
                 .collect()
         })
-        .await
+        .await)
     }
 
     /// Compute the mean interval between consecutive timestamps. Returns None if fewer than 1 timestamp.
diff --git a/raphtory-graphql/src/model/graph/meta_graph.rs b/raphtory-graphql/src/model/graph/meta_graph.rs
index 72316bf2b2..30aac5eff9 100644
--- a/raphtory-graphql/src/model/graph/meta_graph.rs
+++ b/raphtory-graphql/src/model/graph/meta_graph.rs
@@ -1,10 +1,22 @@
-use crate::{model::graph::property::GqlProperty, paths::ExistingGraphFolder};
-use dynamic_graphql::{ResolvedObject, ResolvedObjectFields};
-use raphtory::{errors::GraphError, serialise::metadata::GraphMetadata};
+use crate::{
+    data::Data,
+    model::graph::property::GqlProperty,
+    paths::{ExistingGraphFolder, ValidGraphPaths},
+};
+use async_graphql::Context;
+use dynamic_graphql::{ResolvedObject, ResolvedObjectFields, Result};
+use raphtory::{
+    db::api::storage::storage::{Extension, PersistenceStrategy},
+    prelude::{GraphViewOps, PropertiesOps},
+    serialise::{metadata::GraphMetadata, parquet::decode_graph_metadata},
+};
 use std::{cmp::Ordering, sync::Arc};
 use tokio::sync::OnceCell;
 
-///
+/// Lightweight summary of a stored graph — its name, path, counts, and
+/// filesystem timestamps — served without deserializing the full graph.
+/// Useful for listing what's available on the server before committing to a
+/// full load.
 #[derive(ResolvedObject, Clone)]
 pub(crate) struct MetaGraph {
     folder: ExistingGraphFolder,
@@ -39,10 +51,15 @@ impl MetaGraph {
         }
     }
 
-    async fn meta(&self) -> Result<&GraphMetadata, GraphError> {
-        self.meta
+    pub(crate) fn local_path(&self) -> &str {
+        self.folder.local_path()
+    }
+
+    async fn meta(&self) -> Result<&GraphMetadata> {
+        Ok(self
+            .meta
             .get_or_try_init(|| self.folder.read_metadata_async())
-            .await
+            .await?)
     }
 }
 
@@ -56,26 +73,26 @@ impl MetaGraph {
 
     /// Returns path of graph.
     async fn path(&self) -> String {
-        self.folder.get_original_path_str().to_owned()
+        self.folder.local_path().into()
     }
 
     /// Returns the timestamp for the creation of the graph.
-    async fn created(&self) -> Result<i64, GraphError> {
-        self.folder.created_async().await
+    async fn created(&self) -> Result<i64> {
+        Ok(self.folder.created_async().await?)
     }
 
     /// Returns the graph's last opened timestamp according to system time.
-    async fn last_opened(&self) -> Result<i64, GraphError> {
-        self.folder.last_opened_async().await
+    async fn last_opened(&self) -> Result<i64> {
+        Ok(self.folder.last_opened_async().await?)
     }
 
     /// Returns the graph's last updated timestamp.
-    async fn last_updated(&self) -> Result<i64, GraphError> {
-        self.folder.last_updated_async().await
+    async fn last_updated(&self) -> Result<i64> {
+        Ok(self.folder.last_updated_async().await?)
     }
 
     /// Returns the number of nodes in the graph.
-    async fn node_count(&self) -> Result<usize, GraphError> {
+    async fn node_count(&self) -> Result<usize> {
         Ok(self.meta().await?.node_count)
     }
 
@@ -83,18 +100,31 @@ impl MetaGraph {
     ///
     /// Returns:
     ///     int:
-    async fn edge_count(&self) -> Result<usize, GraphError> {
+    async fn edge_count(&self) -> Result<usize> {
         Ok(self.meta().await?.edge_count)
     }
 
     /// Returns the metadata of the graph.
-    async fn metadata(&self) -> Result<Vec<GqlProperty>, GraphError> {
-        Ok(self
-            .meta()
-            .await?
-            .metadata
-            .iter()
-            .map(|(key, prop)| GqlProperty::new(key.to_string(), prop.clone()))
-            .collect())
+    async fn metadata(&self, ctx: &Context<'_>) -> Result<Vec<GqlProperty>> {
+        let data: &Data = ctx.data_unchecked();
+        let maybe_cached = if Extension::disk_storage_enabled() {
+            let graph = data.get_graph(self.folder.local_path()).await?;
+            Some(graph)
+        } else {
+            data.get_cached_graph(self.folder.local_path()).await
+        };
+        let res = match maybe_cached {
+            None => decode_graph_metadata(self.folder.graph_folder())?
+                .into_iter()
+                .filter_map(|(key, value)| value.map(|prop| GqlProperty::new(key, prop)))
+                .collect(),
+            Some(graph) => graph
+                .graph
+                .metadata()
+                .iter()
+                .filter_map(|(key, value)| value.map(|prop| GqlProperty::new(key.into(), prop)))
+                .collect(),
+        };
+        Ok(res)
     }
 }
diff --git a/raphtory-graphql/src/model/graph/mod.rs b/raphtory-graphql/src/model/graph/mod.rs
index a056b01236..1791b75cfe 100644
--- a/raphtory-graphql/src/model/graph/mod.rs
+++ b/raphtory-graphql/src/model/graph/mod.rs
@@ -6,15 +6,16 @@ pub(crate) mod collection;
 mod document;
 pub(crate) mod edge;
 mod edges;
-pub(crate) mod filtering;
+pub mod filtering;
 pub(crate) mod graph;
 pub(crate) mod history;
 pub(crate) mod index;
 pub(crate) mod meta_graph;
 pub(crate) mod mutable_graph;
 pub(crate) mod namespace;
-mod namespaced_item;
+pub(crate) mod namespaced_item;
 pub(crate) mod node;
+pub(crate) mod node_id;
 mod nodes;
 mod path_from_node;
 pub(crate) mod property;
diff --git a/raphtory-graphql/src/model/graph/mutable_graph.rs b/raphtory-graphql/src/model/graph/mutable_graph.rs
index 49eeeb1356..2cd2537398 100644
--- a/raphtory-graphql/src/model/graph/mutable_graph.rs
+++ b/raphtory-graphql/src/model/graph/mutable_graph.rs
@@ -1,17 +1,25 @@
 use crate::{
     graph::{GraphWithVectors, UpdateEmbeddings},
-    model::graph::{edge::GqlEdge, graph::GqlGraph, node::GqlNode, property::Value},
-    paths::ExistingGraphFolder,
+    model::{
+        graph::{
+            edge::GqlEdge, graph::GqlGraph, node::GqlNode, node_id::GqlNodeId, property::Value,
+            timeindex::GqlTimeInput,
+        },
+        GqlGraphType,
+    },
     rayon::blocking_write,
 };
 use dynamic_graphql::{InputObject, ResolvedObject, ResolvedObjectFields};
 use itertools::Itertools;
 use raphtory::{
-    db::graph::{edge::EdgeView, node::NodeView},
+    db::{
+        api::view::MaterializedGraph,
+        graph::{edge::EdgeView, node::NodeView},
+    },
     errors::GraphError,
     prelude::*,
 };
-use raphtory_api::core::storage::arc_str::OptionAsStr;
+use raphtory_api::core::{storage::arc_str::OptionAsStr, utils::time::IntoTime};
 use std::{
     error::Error,
     fmt::{Debug, Display, Formatter},
@@ -78,30 +86,33 @@ pub struct GqlPropertyInput {
 
 #[derive(InputObject, Clone)]
 pub struct TemporalPropertyInput {
-    /// Time.
-    time: i64,
+    /// Time of the update — accepts the same forms as `TimeInput` (epoch
+    /// millis Int, RFC3339 string, or `{timestamp, eventId}` object).
+    time: GqlTimeInput,
     /// Properties.
     properties: Option<Vec<GqlPropertyInput>>,
 }
 
 #[derive(InputObject, Clone)]
 pub struct NodeAddition {
-    /// Name.
-    name: String,
+    /// Node id (string or non-negative integer).
+    name: GqlNodeId,
     /// Node type.
     node_type: Option<String>,
     /// Metadata.
     metadata: Option<Vec<GqlPropertyInput>>,
     /// Updates.
     updates: Option<Vec<TemporalPropertyInput>>,
+    /// Layer.
+    layer: Option<String>,
 }
 
 #[derive(InputObject, Clone)]
 pub struct EdgeAddition {
-    /// Source node.
-    src: String,
-    /// Destination node.
-    dst: String,
+    /// Source node id (string or non-negative integer).
+    src: GqlNodeId,
+    /// Destination node id (string or non-negative integer).
+    dst: GqlNodeId,
     /// Layer.
     layer: Option<String>,
     /// Metadata.
@@ -110,25 +121,26 @@ pub struct EdgeAddition {
     updates: Option<Vec<TemporalPropertyInput>>,
 }
 
+/// Write-enabled handle for a graph. Obtained by calling `updateGraph(path)`
+/// on the root query with a path you have write permission for. Supports
+/// adding nodes and edges (individually or in batches), attaching
+/// properties/metadata, and looking up mutable `node`/`edge` handles. Use the
+/// read-only `graph(path)` resolver for queries.
 #[derive(ResolvedObject, Clone)]
 #[graphql(name = "MutableGraph")]
 pub struct GqlMutableGraph {
-    path: ExistingGraphFolder,
     graph: GraphWithVectors,
 }
 
-impl GqlMutableGraph {
-    pub(crate) fn new(path: ExistingGraphFolder, graph: GraphWithVectors) -> Self {
-        Self {
-            path: path.into(),
-            graph,
-        }
+impl From<GraphWithVectors> for GqlMutableGraph {
+    fn from(graph: GraphWithVectors) -> Self {
+        Self { graph }
     }
 }
 
 fn as_properties(
     properties: Vec<GqlPropertyInput>,
-) -> Result<impl Iterator<Item = (String, Prop)>, GraphError> {
+) -> Result<impl ExactSizeIterator<Item = (String, Prop)>, GraphError> {
     let props: Result<Vec<(String, Prop)>, GraphError> = properties
         .into_iter()
         .map(|p| {
@@ -142,62 +154,127 @@ fn as_properties(
 
 #[ResolvedObjectFields]
 impl GqlMutableGraph {
-    /// Get the non-mutable graph.
-    async fn graph(&self) -> GqlGraph {
-        GqlGraph::new(self.path.clone(), self.graph.graph.clone())
+    /// Read-only view of this graph — identical to what you'd get from
+    /// `graph(path:)` on the query root. Use this when you want to compose
+    /// queries on the graph you've just mutated. `graphType` lets you
+    /// re-interpret the graph at query time (see `graph(path:)` for
+    /// semantics); defaults to the stored graph's native type.
+    async fn graph(
+        &self,
+        #[graphql(
+            desc = "Optional override for graph semantics — `EVENT` treats every update as a point-in-time event, `PERSISTENT` carries values forward until overwritten or deleted. Defaults to the stored graph's native type."
+        )]
+        graph_type: Option<GqlGraphType>,
+    ) -> GqlGraph {
+        let folder = self.graph.folder.clone();
+        match graph_type {
+            Some(GqlGraphType::Event) => match self.graph.graph.clone() {
+                MaterializedGraph::EventGraph(g) => GqlGraph::new(folder, g),
+                MaterializedGraph::PersistentGraph(g) => GqlGraph::new(folder, g.event_graph()),
+            },
+            Some(GqlGraphType::Persistent) => match self.graph.graph.clone() {
+                MaterializedGraph::EventGraph(g) => GqlGraph::new(folder, g.persistent_graph()),
+                MaterializedGraph::PersistentGraph(g) => GqlGraph::new(folder, g),
+            },
+            None => GqlGraph::new(folder, self.graph.graph.clone()),
+        }
     }
 
-    /// Get mutable existing node.
-    async fn node(&self, name: String) -> Option<GqlMutableNode> {
-        self.graph.node(name).map(|n| n.into())
+    /// Look up an existing node for mutation. Returns null if the node doesn't
+    /// exist; use `addNode` or `createNode` to create one.
+
+    async fn node(&self, #[graphql(desc = "Node id.")] name: GqlNodeId) -> Option<GqlMutableNode> {
+        self.graph.node(name).map(|n| GqlMutableNode::new(n))
     }
 
-    /// Add a new node or add updates to an existing node.
+    /// Add a new node or append an update to an existing one. Upsert semantics:
+    /// no error if the node already exists — properties and type are merged.
+
     async fn add_node(
         &self,
-        time: i64,
-        name: String,
-        properties: Option<Vec<GqlPropertyInput>>,
+        #[graphql(desc = "Time of the event.")] time: GqlTimeInput,
+        #[graphql(desc = "Node id.")] name: GqlNodeId,
+        #[graphql(desc = "Optional property updates attached to this event.")] properties: Option<
+            Vec<GqlPropertyInput>,
+        >,
+        #[graphql(
+            desc = "Optional node type to assign. If provided, sets the node's type at this event."
+        )]
         node_type: Option<String>,
+        #[graphql(desc = "Optional layer name. If omitted, the default layer is used.")]
+        layer: Option<String>,
     ) -> Result<GqlMutableNode, GraphError> {
         let self_clone = self.clone();
         let node = blocking_write(move || {
             let prop_iter = as_properties(properties.unwrap_or(vec![]))?;
-            let node = self_clone
-                .graph
-                .add_node(time, &name, prop_iter, node_type.as_str())?;
-            self_clone.graph.write_updates()?;
+            let node = self_clone.graph.add_node(
+                time.into_input_time(),
+                &name,
+                prop_iter,
+                node_type.as_str(),
+                layer.as_str(),
+            )?;
+
             Ok::<_, GraphError>(node)
         })
         .await?;
+
+        self.post_mutation_ops().await;
         let _ = node.update_embeddings().await;
-        Ok(node.into())
+
+        Ok(GqlMutableNode::new(node))
     }
 
-    /// Create a new node or fail if it already exists.
+    /// Create a new node or fail if it already exists. Strict alternative to
+    /// `addNode` — use this when you want to detect collisions.
+
     async fn create_node(
         &self,
-        time: i64,
-        name: String,
-        properties: Option<Vec<GqlPropertyInput>>,
+        #[graphql(desc = "Time of the create event.")] time: GqlTimeInput,
+        #[graphql(desc = "Node id.")] name: GqlNodeId,
+        #[graphql(desc = "Optional property updates attached to this event.")] properties: Option<
+            Vec<GqlPropertyInput>,
+        >,
+        #[graphql(
+            desc = "Optional node type to assign. If provided, sets the node's type at this event."
+        )]
         node_type: Option<String>,
+        #[graphql(desc = "Optional layer name. If omitted, the default layer is used.")]
+        layer: Option<String>,
     ) -> Result<GqlMutableNode, GraphError> {
         let self_clone = self.clone();
         let node = blocking_write(move || {
             let prop_iter = as_properties(properties.unwrap_or(vec![]))?;
-            let node = self_clone
-                .graph
-                .create_node(time, &name, prop_iter, node_type.as_str())?;
-            self_clone.graph.write_updates()?;
+            let node = self_clone.graph.create_node(
+                time.into_input_time(),
+                &name,
+                prop_iter,
+                node_type.as_str(),
+                layer.as_str(),
+            )?;
+
             Ok::<_, GraphError>(node)
         })
         .await?;
+
+        self.post_mutation_ops().await;
         let _ = node.update_embeddings().await;
-        Ok(node.into())
+
+        Ok(GqlMutableNode::new(node))
     }
 
-    /// Add a batch of nodes.
-    async fn add_nodes(&self, nodes: Vec<NodeAddition>) -> Result<bool, BatchFailures> {
+    /// Batch-add multiple nodes in one call. For each `NodeAddition`, applies every
+    /// update it carries (time/properties pairs), then optionally sets its node type
+    /// and adds any metadata. On partial failure, returns a `BatchFailures` error
+    /// describing which entries failed and why; otherwise returns true.
+
+    async fn add_nodes(
+        &self,
+        #[graphql(
+            desc = "List of `NodeAddition` inputs, each specifying a node's name, optional type, layer, per-timestamp updates, and metadata."
+        )]
+        nodes: Vec<NodeAddition>,
+    ) -> Result<bool, BatchFailures> {
         let self_clone = self.clone();
 
         let (succeeded, batch_failures) = blocking_write(move || {
@@ -205,13 +282,19 @@ impl GqlMutableGraph {
                 .iter()
                 .map(|node| {
                     let node = node.clone();
-                    let name = node.name.as_str();
+                    let name = &node.name;
+                    let node_type = node.node_type.as_str();
+                    let layer = node.layer.as_str();
 
                     for prop in node.updates.unwrap_or(vec![]) {
                         let prop_iter = as_properties(prop.properties.unwrap_or(vec![]))?;
-                        self_clone
-                            .graph
-                            .add_node(prop.time, name, prop_iter, None)?;
+                        self_clone.graph.add_node(
+                            prop.time.into_input_time(),
+                            name,
+                            prop_iter,
+                            node_type,
+                            layer,
+                        )?;
                     }
                     if let Some(node_type) = node.node_type.as_str() {
                         self_clone.get_node_view(name)?.set_node_type(node_type)?;
@@ -224,10 +307,13 @@ impl GqlMutableGraph {
                     self_clone.get_node_view(name)
                 })
                 .collect();
-            let write_res = self_clone.graph.write_updates();
-            split_failures(nodes, write_res)
+
+            split_failures(nodes, Ok(()))
         })
         .await;
+
+        self.post_mutation_ops().await;
+
         // Generate embeddings
         let _ = self.graph.update_node_embeddings(succeeded).await;
         if let Some(failures) = batch_failures {
@@ -237,165 +323,243 @@ impl GqlMutableGraph {
         }
     }
 
-    /// Get a mutable existing edge.
-    async fn edge(&self, src: String, dst: String) -> Option<GqlMutableEdge> {
-        self.graph.edge(src, dst).map(|e| e.into())
+    /// Look up an existing edge for mutation. Returns null if no such edge exists.
+
+    async fn edge(
+        &self,
+        #[graphql(desc = "Source node id.")] src: GqlNodeId,
+        #[graphql(desc = "Destination node id.")] dst: GqlNodeId,
+    ) -> Option<GqlMutableEdge> {
+        self.graph.edge(src, dst).map(|e| GqlMutableEdge::new(e))
     }
 
-    /// Add a new edge or add updates to an existing edge.
+    /// Add a new edge or append an update to an existing one. Upsert semantics:
+    /// safe to call on an edge that already exists — creates missing endpoints if
+    /// needed.
+
     async fn add_edge(
         &self,
-        time: i64,
-        src: String,
-        dst: String,
-        properties: Option<Vec<GqlPropertyInput>>,
+        #[graphql(desc = "Time of the event.")] time: GqlTimeInput,
+        #[graphql(desc = "Source node id.")] src: GqlNodeId,
+        #[graphql(desc = "Destination node id.")] dst: GqlNodeId,
+        #[graphql(desc = "Optional property updates attached to this event.")] properties: Option<
+            Vec<GqlPropertyInput>,
+        >,
+        #[graphql(desc = "Optional layer name. If omitted, the default layer is used.")]
         layer: Option<String>,
     ) -> Result<GqlMutableEdge, GraphError> {
         let self_clone = self.clone();
         let edge = blocking_write(move || {
             let prop_iter = as_properties(properties.unwrap_or(vec![]))?;
-            let edge = self_clone
-                .graph
-                .add_edge(time, src, dst, prop_iter, layer.as_str())?;
-            self_clone.graph.write_updates()?;
+            let edge = self_clone.graph.add_edge(
+                time.into_input_time(),
+                src,
+                dst,
+                prop_iter,
+                layer.as_str(),
+            )?;
+
             Ok::<_, GraphError>(edge)
         })
         .await?;
+
+        self.post_mutation_ops().await;
         let _ = edge.update_embeddings().await;
-        Ok(edge.into())
+
+        Ok(GqlMutableEdge::new(edge))
     }
 
-    /// Add a batch of edges.
-    async fn add_edges(&self, edges: Vec<EdgeAddition>) -> Result<bool, BatchFailures> {
+    /// Batch-add multiple edges in one call. For each `EdgeAddition`, applies every
+    /// update it carries, then adds any metadata. On partial failure, returns a
+    /// `BatchFailures` error describing which entries failed; otherwise returns
+    /// true.
+
+    async fn add_edges(
+        &self,
+        #[graphql(
+            desc = "List of `EdgeAddition` inputs, each specifying an edge's `src`, `dst`, optional layer, per-timestamp updates, and metadata."
+        )]
+        edges: Vec<EdgeAddition>,
+    ) -> Result<bool, BatchFailures> {
         let self_clone = self.clone();
 
         let (edge_pairs, failures) = blocking_write(move || {
             let edge_res: Vec<_> = edges
                 .into_iter()
                 .map(|edge| {
-                    let src = edge.src.as_str();
-                    let dst = edge.dst.as_str();
+                    let src = &edge.src;
+                    let dst = &edge.dst;
                     let layer = edge.layer.as_str();
                     for prop in edge.updates.unwrap_or(vec![]) {
                         let prop_iter = as_properties(prop.properties.unwrap_or(vec![]))?;
-                        self_clone
-                            .graph
-                            .add_edge(prop.time, src, dst, prop_iter, layer)?;
+                        self_clone.graph.add_edge(
+                            prop.time.into_input_time(),
+                            src,
+                            dst,
+                            prop_iter,
+                            layer,
+                        )?;
                     }
                     let metadata = edge.metadata.unwrap_or(vec![]);
                     if !metadata.is_empty() {
                         let prop_iter = as_properties(metadata)?;
                         self_clone
-                            .get_edge_view(src.to_string(), dst.to_string())?
+                            .get_edge_view(src, dst)?
                             .add_metadata(prop_iter, layer)?;
                     }
                     Ok((edge.src, edge.dst))
                 })
                 .collect();
-            let write_res = self_clone.graph.write_updates();
-            split_failures(edge_res, write_res)
+
+            split_failures(edge_res, Ok(()))
         })
         .await;
 
+        self.post_mutation_ops().await;
         let _ = self.graph.update_edge_embeddings(edge_pairs).await;
+
         match failures {
             None => Ok(true),
             Some(failures) => Err(failures),
         }
     }
 
-    /// Mark an edge as deleted (creates the edge if it did not exist).
+    /// Mark an edge as deleted at the given time. Persistent graphs treat this
+    /// as a tombstone (the edge becomes invalid from `time` onwards); event
+    /// graphs simply log the deletion event. Creates the edge first if it did
+    /// not exist.
+
     async fn delete_edge(
         &self,
-        time: i64,
-        src: String,
-        dst: String,
+        #[graphql(desc = "Time of the deletion.")] time: GqlTimeInput,
+        #[graphql(desc = "Source node id.")] src: GqlNodeId,
+        #[graphql(desc = "Destination node id.")] dst: GqlNodeId,
+        #[graphql(desc = "Optional layer name. If omitted, the default layer is used.")]
         layer: Option<String>,
     ) -> Result<GqlMutableEdge, GraphError> {
         let self_clone = self.clone();
         let edge = blocking_write(move || {
-            let edge = self_clone
-                .graph
-                .delete_edge(time, src, dst, layer.as_str())?;
-            self_clone.graph.write_updates()?;
+            let edge =
+                self_clone
+                    .graph
+                    .delete_edge(time.into_input_time(), src, dst, layer.as_str())?;
+
             Ok::<_, GraphError>(edge)
         })
         .await?;
+
+        self.post_mutation_ops().await;
         let _ = edge.update_embeddings().await;
-        Ok(edge.into())
+
+        Ok(GqlMutableEdge::new(edge))
     }
 
-    /// Add temporal properties to graph.
+    /// Add temporal properties to the graph itself (not a node or edge). Each
+    /// call records a property update at `t`.
+
     async fn add_properties(
         &self,
-        t: i64,
-        properties: Vec<GqlPropertyInput>,
+        #[graphql(desc = "Time of the update.")] t: GqlTimeInput,
+        #[graphql(desc = "List of `{key, value}` pairs to set.")] properties: Vec<GqlPropertyInput>,
     ) -> Result<bool, GraphError> {
         let self_clone = self.clone();
-        blocking_write(move || {
+        let result = blocking_write(move || {
             self_clone
                 .graph
-                .add_properties(t, as_properties(properties)?)?;
-            self_clone.graph.write_updates()?;
+                .add_properties(t.into_input_time(), as_properties(properties)?)?;
             Ok(true)
         })
-        .await
+        .await;
+
+        self.post_mutation_ops().await;
+
+        result
     }
 
-    /// Add metadata to graph (errors if the property already exists).
-    async fn add_metadata(&self, properties: Vec<GqlPropertyInput>) -> Result<bool, GraphError> {
+    /// Add metadata to the graph itself. Errors if any of the keys already
+    /// exists — use `updateMetadata` to overwrite.
+
+    async fn add_metadata(
+        &self,
+        #[graphql(desc = "List of `{key, value}` pairs to set as metadata.")] properties: Vec<
+            GqlPropertyInput,
+        >,
+    ) -> Result<bool, GraphError> {
         let self_clone = self.clone();
-        blocking_write(move || {
+        let result = blocking_write(move || {
             self_clone.graph.add_metadata(as_properties(properties)?)?;
-            self_clone.graph.write_updates()?;
             Ok(true)
         })
-        .await
+        .await;
+        self.post_mutation_ops().await;
+
+        result
     }
 
-    /// Update metadata of the graph (overwrites existing values).
-    async fn update_metadata(&self, properties: Vec<GqlPropertyInput>) -> Result<bool, GraphError> {
+    /// Update metadata of the graph itself, overwriting any existing values for
+    /// the given keys.
+
+    async fn update_metadata(
+        &self,
+        #[graphql(desc = "List of `{key, value}` pairs to upsert.")] properties: Vec<
+            GqlPropertyInput,
+        >,
+    ) -> Result<bool, GraphError> {
         let self_clone = self.clone();
-        blocking_write(move || {
+        let result = blocking_write(move || {
             self_clone
                 .graph
                 .update_metadata(as_properties(properties)?)?;
-            self_clone.graph.write_updates()?;
             Ok(true)
         })
-        .await
+        .await;
+
+        self.post_mutation_ops().await;
+
+        result
     }
 }
 
 impl GqlMutableGraph {
-    fn get_node_view(&self, name: &str) -> Result<NodeView<'static, GraphWithVectors>, GraphError> {
+    fn get_node_view(
+        &self,
+        name: &GqlNodeId,
+    ) -> Result<NodeView<'static, GraphWithVectors>, GraphError> {
         self.graph
             .node(name)
-            .ok_or_else(|| GraphError::NodeMissingError(GID::Str(name.to_owned())))
+            .ok_or_else(|| GraphError::NodeMissingError(name.0.clone()))
     }
 
     fn get_edge_view(
         &self,
-        src: String,
-        dst: String,
+        src: &GqlNodeId,
+        dst: &GqlNodeId,
     ) -> Result<EdgeView<GraphWithVectors>, GraphError> {
         self.graph
-            .edge(src.clone(), dst.clone())
-            .ok_or(GraphError::EdgeMissingError {
-                src: GID::Str(src),
-                dst: GID::Str(dst),
+            .edge(src, dst)
+            .ok_or_else(|| GraphError::EdgeMissingError {
+                src: src.0.clone(),
+                dst: dst.0.clone(),
             })
     }
+
+    /// Post mutation operations.
+    async fn post_mutation_ops(&self) {
+        self.graph.set_dirty(true);
+    }
 }
 
+/// Write-side handle for a single node — returned from `addNode`, `createNode`,
+/// or `MutableGraph.node`. Supports adding updates, setting node type, and
+/// attaching or updating metadata.
 #[derive(ResolvedObject, Clone)]
 #[graphql(name = "MutableNode")]
 pub struct GqlMutableNode {
     node: NodeView<'static, GraphWithVectors>,
 }
 
-impl From<NodeView<'static, GraphWithVectors>> for GqlMutableNode {
-    fn from(node: NodeView<'static, GraphWithVectors>) -> Self {
+impl GqlMutableNode {
+    pub fn new(node: NodeView<'static, GraphWithVectors>) -> Self {
         Self { node }
     }
 }
@@ -412,77 +576,116 @@ impl GqlMutableNode {
         self.node.clone().into()
     }
 
-    /// Add metadata to the node (errors if the property already exists).
-    async fn add_metadata(&self, properties: Vec<GqlPropertyInput>) -> Result<bool, GraphError> {
+    /// Add metadata to this node. Errors if any of the keys already exists —
+    /// use `updateMetadata` to overwrite.
+
+    async fn add_metadata(
+        &self,
+        #[graphql(desc = "List of `{key, value}` pairs to set as metadata.")] properties: Vec<
+            GqlPropertyInput,
+        >,
+    ) -> Result<bool, GraphError> {
         let self_clone = self.clone();
         blocking_write(move || {
             self_clone.node.add_metadata(as_properties(properties)?)?;
-            self_clone.node.graph.write_updates()?;
             Ok::<_, GraphError>(())
         })
         .await?;
-        let _ = self.node.update_embeddings().await;
+
+        self.post_mutation_ops().await;
+
         Ok(true)
     }
 
-    /// Set the node type (errors if the node already has a non-default type).
-    async fn set_node_type(&self, new_type: String) -> Result<bool, GraphError> {
+    /// Set this node's type. Errors if the node already has a non-default
+    /// type and you're trying to change it.
+
+    async fn set_node_type(
+        &self,
+        #[graphql(desc = "Node-type name to assign.")] new_type: String,
+    ) -> Result<bool, GraphError> {
         let self_clone = self.clone();
         blocking_write(move || {
             self_clone.node.set_node_type(&new_type)?;
-
-            self_clone.node.graph.write_updates()?;
             Ok::<_, GraphError>(())
         })
         .await?;
-        let _ = self.node.update_embeddings().await;
+
+        self.post_mutation_ops().await;
+
         Ok(true)
     }
 
-    /// Update metadata of the node (overwrites existing property values).
-    async fn update_metadata(&self, properties: Vec<GqlPropertyInput>) -> Result<bool, GraphError> {
+    /// Update metadata of this node, overwriting any existing values for the
+    /// given keys.
+
+    async fn update_metadata(
+        &self,
+        #[graphql(desc = "List of `{key, value}` pairs to upsert.")] properties: Vec<
+            GqlPropertyInput,
+        >,
+    ) -> Result<bool, GraphError> {
         let self_clone = self.clone();
         blocking_write(move || {
             self_clone
                 .node
                 .update_metadata(as_properties(properties)?)?;
 
-            self_clone.node.graph.write_updates()?;
             Ok::<_, GraphError>(())
         })
         .await?;
-        let _ = self.node.update_embeddings().await;
+
+        self.post_mutation_ops().await;
+
         Ok(true)
     }
 
-    /// Add temporal property updates to the node.
+    /// Append a property update to this node at a specific time.
+
     async fn add_updates(
         &self,
-        time: i64,
+        #[graphql(desc = "Time of the update.")] time: GqlTimeInput,
+        #[graphql(desc = "Optional `{key, value}` pairs attached to the event.")]
         properties: Option<Vec<GqlPropertyInput>>,
+        #[graphql(desc = "Optional layer name. If omitted, the default layer is used.")]
+        layer: Option<String>,
     ) -> Result<bool, GraphError> {
         let self_clone = self.clone();
         blocking_write(move || {
-            self_clone
-                .node
-                .add_updates(time, as_properties(properties.unwrap_or(vec![]))?)?;
-            self_clone.node.graph.write_updates()?;
+            self_clone.node.add_updates(
+                time.into_input_time(),
+                as_properties(properties.unwrap_or(vec![]))?,
+                layer.as_str(),
+            )?;
             Ok::<_, GraphError>(())
         })
         .await?;
+
+        self.post_mutation_ops().await;
         let _ = self.node.update_embeddings().await;
+
         Ok(true)
     }
 }
 
+impl GqlMutableNode {
+    /// Post mutation operations.
+    async fn post_mutation_ops(&self) {
+        self.node.graph.set_dirty(true);
+    }
+}
+
+/// Write-side handle for a single edge — returned from `addEdge` or
+/// `MutableGraph.edge`. Supports adding updates, deletions, and attaching
+/// or updating metadata.
 #[derive(ResolvedObject, Clone)]
 #[graphql(name = "MutableEdge")]
 pub struct GqlMutableEdge {
     edge: EdgeView<GraphWithVectors>,
 }
 
-impl From<EdgeView<GraphWithVectors>> for GqlMutableEdge {
-    fn from(edge: EdgeView<GraphWithVectors>) -> Self {
+impl GqlMutableEdge {
+    pub fn new(edge: EdgeView<GraphWithVectors>) -> Self {
         Self { edge }
     }
 }
@@ -501,36 +704,53 @@ impl GqlMutableEdge {
 
     /// Get the mutable source node of the edge.
     async fn src(&self) -> GqlMutableNode {
-        self.edge.src().into()
+        GqlMutableNode::new(self.edge.src())
     }
 
     /// Get the mutable destination node of the edge.
     async fn dst(&self) -> GqlMutableNode {
-        self.edge.dst().into()
+        GqlMutableNode::new(self.edge.dst())
     }
 
-    /// Mark the edge as deleted at time time.
-    async fn delete(&self, time: i64, layer: Option<String>) -> Result<bool, GraphError> {
+    /// Mark this edge as deleted at the given time. Persistent graphs treat this
+    /// as a tombstone (the edge becomes invalid from `time` onwards); event
+    /// graphs simply log the deletion event.
+
+    async fn delete(
+        &self,
+        #[graphql(desc = "Time of the deletion.")] time: GqlTimeInput,
+        #[graphql(
+            desc = "Optional layer name. If omitted, uses the layer the edge was originally added on (when called after `addEdge`)."
+        )]
+        layer: Option<String>,
+    ) -> Result<bool, GraphError> {
         let self_clone = self.clone();
         blocking_write(move || {
-            self_clone.edge.delete(time, layer.as_str())?;
-
-            self_clone.edge.graph.write_updates()?;
+            self_clone
+                .edge
+                .delete(time.into_input_time(), layer.as_str())?;
             Ok::<_, GraphError>(())
         })
         .await?;
+
+        self.post_mutation_ops().await;
         let _ = self.edge.update_embeddings().await;
+
         Ok(true)
     }
 
-    /// Add metadata to the edge (errors if the value already exists).
-    ///
-    /// If this is called after add_edge, the layer is inherited from the add_edge and does not
-    /// need to be specified again.
+    /// Add metadata to this edge. Errors if any of the keys already exists —
+    /// use `updateMetadata` to overwrite. If this is called after `addEdge`,
+    /// the layer is inherited and does not need to be specified again.
+
     async fn add_metadata(
         &self,
-        properties: Vec<GqlPropertyInput>,
-        layer: Option<String>,
+        #[graphql(desc = "List of `{key, value}` pairs to set as metadata.")] properties: Vec<
+            GqlPropertyInput,
+        >,
+        #[graphql(desc = "Optional layer name; defaults to the inherited layer.")] layer: Option<
+            String,
+        >,
     ) -> Result<bool, GraphError> {
         let self_clone = self.clone();
         blocking_write(move || {
@@ -538,22 +758,28 @@ impl GqlMutableEdge {
                 .edge
                 .add_metadata(as_properties(properties)?, layer.as_str())?;
 
-            self_clone.edge.graph.write_updates()?;
             Ok::<_, GraphError>(())
         })
         .await?;
+
+        self.post_mutation_ops().await;
         let _ = self.edge.update_embeddings().await;
+
         Ok(true)
     }
 
-    /// Update metadata of the edge (existing values are overwritten).
-    ///
-    /// If this is called after add_edge, the layer is inherited from the add_edge and does not
-    /// need to be specified again.
+    /// Update metadata of this edge, overwriting any existing values for the
+    /// given keys. If this is called after `addEdge`, the layer is inherited
+    /// and does not need to be specified again.
+
     async fn update_metadata(
         &self,
-        properties: Vec<GqlPropertyInput>,
-        layer: Option<String>,
+        #[graphql(desc = "List of `{key, value}` pairs to upsert.")] properties: Vec<
+            GqlPropertyInput,
+        >,
+        #[graphql(desc = "Optional layer name; defaults to the inherited layer.")] layer: Option<
+            String,
+        >,
     ) -> Result<bool, GraphError> {
         let self_clone = self.clone();
         blocking_write(move || {
@@ -561,53 +787,65 @@ impl GqlMutableEdge {
                 .edge
                 .update_metadata(as_properties(properties)?, layer.as_str())?;
 
-            self_clone.edge.graph.write_updates()?;
             Ok::<_, GraphError>(())
         })
         .await?;
+
+        self.post_mutation_ops().await;
         let _ = self.edge.update_embeddings().await;
+
         Ok(true)
     }
 
-    /// Add temporal property updates to the edge.
-    ///
-    /// If this is called after add_edge, the layer is inherited from the add_edge and does not
-    /// need to be specified again.
+    /// Append a property update to this edge at a specific time. If called
+    /// after `addEdge`, the layer is inherited and does not need to be
+    /// specified again.
+
     async fn add_updates(
         &self,
-        time: i64,
+        #[graphql(desc = "Time of the update.")] time: GqlTimeInput,
+        #[graphql(desc = "Optional `{key, value}` pairs attached to the event.")]
         properties: Option<Vec<GqlPropertyInput>>,
-        layer: Option<String>,
+        #[graphql(desc = "Optional layer name; defaults to the inherited layer.")] layer: Option<
+            String,
+        >,
     ) -> Result<bool, GraphError> {
         let self_clone = self.clone();
         blocking_write(move || {
             self_clone.edge.add_updates(
-                time,
+                time.into_input_time(),
                 as_properties(properties.unwrap_or(vec![]))?,
                 layer.as_str(),
             )?;
-            self_clone.edge.graph.write_updates()?;
+
             Ok::<_, GraphError>(())
         })
         .await?;
+
+        self.post_mutation_ops().await;
         let _ = self.edge.update_embeddings().await;
+
         Ok(true)
     }
 }
 
+impl GqlMutableEdge {
+    /// Post mutation operations.
+    async fn post_mutation_ops(&self) {
+        self.edge.graph.set_dirty(true);
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{config::app_config::AppConfig, data::Data};
-    use itertools::Itertools;
+    use crate::{config::app_config::AppConfig, data::Data, paths::ExistingGraphFolder};
     use raphtory::{
-        db::api::view::MaterializedGraph,
+        db::api::{storage::storage::Config, view::MaterializedGraph},
         vectors::{
             custom::{serve_custom_embedding, EmbeddingServer},
-            embeddings::EmbeddingResult,
             storage::OpenAIEmbeddings,
             template::DocumentTemplate,
-            Embedding,
         },
     };
     use tempfile::tempdir;
@@ -623,17 +861,20 @@ mod tests {
 
     async fn create_mutable_graph(
         port: u16,
-    ) -> (GqlMutableGraph, tempfile::TempDir, EmbeddingServer) {
+    ) -> (GqlMutableGraph, Data, tempfile::TempDir, EmbeddingServer) {
         let graph = create_test_graph();
         let tmp_dir = tempdir().unwrap();
 
         let config = AppConfig::default();
-        let data = Data::new(tmp_dir.path(), &config);
+        let data = Data::new(tmp_dir.path(), &config, Config::default());
 
         let graph_name = "test_graph";
 
-        data.insert_graph(graph_name, graph).await.unwrap();
-
+        let overwrite = false;
+        let folder = data
+            .validate_path_for_insert(graph_name, overwrite)
+            .unwrap();
+        data.insert_graph(folder.clone(), graph).await.unwrap();
         let template = DocumentTemplate {
             node_template: Some("{{ name }} is a {{ node_type }}".to_string()),
             edge_template: Some("{{ src.name }} appeared with {{ dst.name}}".to_string()),
@@ -652,15 +893,15 @@ mod tests {
         .await
         .unwrap();
 
-        let (graph_with_vectors, path) = data.get_graph(graph_name).await.unwrap();
-        let mutable_graph = GqlMutableGraph::new(path, graph_with_vectors);
+        let graph_with_vectors = data.get_graph(graph_name).await.unwrap();
+        let mutable_graph = GqlMutableGraph::from(graph_with_vectors);
 
-        (mutable_graph, tmp_dir, embedding_server)
+        (mutable_graph, data, tmp_dir, embedding_server)
     }
 
     #[tokio::test]
     async fn test_add_nodes_empty_list() {
-        let (mutable_graph, _tmp_dir, embedding_server) = create_mutable_graph(1745).await;
+        let (mutable_graph, _data, _tmp_dir, embedding_server) = create_mutable_graph(1745).await;
 
         let nodes = vec![];
         let result = mutable_graph.add_nodes(nodes).await;
@@ -671,27 +912,30 @@ mod tests {
     }
 
     #[tokio::test]
+    #[ignore = "TODO: #2384"]
     async fn test_add_nodes_simple() {
-        let (mutable_graph, _tmp_dir, es) = create_mutable_graph(1746).await;
+        let (mutable_graph, _data, _tmp_dir, es) = create_mutable_graph(1746).await;
 
         let nodes = vec![
             NodeAddition {
-                name: "node1".to_string(),
+                name: "node1".into(),
                 node_type: Some("test_node_type".to_string()),
                 metadata: None,
                 updates: Some(vec![TemporalPropertyInput {
-                    time: 0,
+                    time: 0.into(),
                     properties: None,
                 }]),
+                layer: None,
             },
             NodeAddition {
-                name: "node2".to_string(),
+                name: "node2".into(),
                 node_type: Some("test_node_type".to_string()),
                 metadata: None,
                 updates: Some(vec![TemporalPropertyInput {
-                    time: 0,
+                    time: 0.into(),
                     properties: None,
                 }]),
+                layer: None,
             },
         ];
 
@@ -716,12 +960,13 @@ mod tests {
     }
 
     #[tokio::test]
+    #[ignore = "TODO: #2384"]
     async fn test_add_nodes_with_properties() {
-        let (mutable_graph, _tmp_dir, es) = create_mutable_graph(1747).await;
+        let (mutable_graph, _data, _tmp_dir, es) = create_mutable_graph(1747).await;
 
         let nodes = vec![
             NodeAddition {
-                name: "complex_node_1".to_string(),
+                name: "complex_node_1".into(),
                 node_type: Some("employee".to_string()),
                 metadata: Some(vec![GqlPropertyInput {
                     key: "department".to_string(),
@@ -729,41 +974,44 @@ mod tests {
                 }]),
                 updates: Some(vec![
                     TemporalPropertyInput {
-                        time: 0,
+                        time: 0.into(),
                         properties: Some(vec![GqlPropertyInput {
                             key: "salary".to_string(),
                             value: Value::F64(50000.0),
                         }]),
                     },
                     TemporalPropertyInput {
-                        time: 0,
+                        time: 0.into(),
                         properties: Some(vec![GqlPropertyInput {
                             key: "salary".to_string(),
                             value: Value::F64(55000.0),
                         }]),
                     },
                 ]),
+                layer: None,
             },
             NodeAddition {
-                name: "complex_node_2".to_string(),
+                name: "complex_node_2".into(),
                 node_type: Some("employee".to_string()),
                 metadata: None,
                 updates: Some(vec![TemporalPropertyInput {
-                    time: 0,
+                    time: 0.into(),
                     properties: None,
                 }]),
+                layer: None,
             },
             NodeAddition {
-                name: "complex_node_3".to_string(),
+                name: "complex_node_3".into(),
                 node_type: Some("employee".to_string()),
                 metadata: None,
                 updates: Some(vec![TemporalPropertyInput {
-                    time: 0,
+                    time: 0.into(),
                     properties: Some(vec![GqlPropertyInput {
                         key: "salary".to_string(),
                         value: Value::F64(55000.0),
                     }]),
                 }]),
+                layer: None,
             },
         ];
 
@@ -788,28 +1036,31 @@ mod tests {
     }
 
     #[tokio::test]
+    #[ignore = "TODO: #2384"]
     async fn test_add_edges_simple() {
-        let (mutable_graph, _tmp_dir, es) = create_mutable_graph(1748).await;
+        let (mutable_graph, _data, _tmp_dir, es) = create_mutable_graph(1748).await;
 
         // First add some nodes.
         let nodes = vec![
             NodeAddition {
-                name: "node1".to_string(),
+                name: "node1".into(),
                 node_type: Some("person".to_string()),
                 metadata: None,
                 updates: Some(vec![TemporalPropertyInput {
-                    time: 0,
+                    time: 0.into(),
                     properties: None,
                 }]),
+                layer: None,
             },
             NodeAddition {
-                name: "node2".to_string(),
+                name: "node2".into(),
                 node_type: Some("person".to_string()),
                 metadata: None,
                 updates: Some(vec![TemporalPropertyInput {
-                    time: 0,
+                    time: 0.into(),
                     properties: None,
                 }]),
+                layer: None,
             },
         ];
 
@@ -819,25 +1070,25 @@ mod tests {
         // Now add edges between them.
         let edges = vec![
             EdgeAddition {
-                src: "node1".to_string(),
-                dst: "node2".to_string(),
+                src: "node1".into(),
+                dst: "node2".into(),
                 layer: Some("friendship".to_string()),
                 metadata: Some(vec![GqlPropertyInput {
                     key: "strength".to_string(),
                     value: Value::F64(0.8),
                 }]),
                 updates: Some(vec![TemporalPropertyInput {
-                    time: 0,
+                    time: 0.into(),
                     properties: None,
                 }]),
             },
             EdgeAddition {
-                src: "node2".to_string(),
-                dst: "node1".to_string(),
+                src: "node2".into(),
+                dst: "node1".into(),
                 layer: Some("friendship".to_string()),
                 metadata: None,
                 updates: Some(vec![TemporalPropertyInput {
-                    time: 0,
+                    time: 0.into(),
                     properties: None,
                 }]),
             },
@@ -848,6 +1099,7 @@ mod tests {
         assert!(result.is_ok());
         assert!(result.unwrap());
 
+        // TODO: #2380 (embeddings aren't working right now)
         // Test that edge embeddings were generated.
         let embedding = fake_embedding("node1 appeared with node2");
         let limit = 5;
diff --git a/raphtory-graphql/src/model/graph/namespace.rs b/raphtory-graphql/src/model/graph/namespace.rs
index b6001a2651..cdf13fb9bf 100644
--- a/raphtory-graphql/src/model/graph/namespace.rs
+++ b/raphtory-graphql/src/model/graph/namespace.rs
@@ -1,134 +1,252 @@
 use crate::{
-    data::get_relative_path,
+    auth_policy::{AuthorizationPolicy, NamespacePermission},
+    data::{get_relative_path, Data},
     model::graph::{
         collection::GqlCollection, meta_graph::MetaGraph, namespaced_item::NamespacedItem,
     },
-    paths::{valid_path, ExistingGraphFolder},
+    paths::{ExistingGraphFolder, PathValidationError, ValidPath},
     rayon::blocking_compute,
 };
+use async_graphql::Context;
 use dynamic_graphql::{ResolvedObject, ResolvedObjectFields};
 use itertools::Itertools;
-use raphtory::errors::InvalidPathReason;
-use std::path::PathBuf;
+use std::{path::PathBuf, sync::Arc};
 use walkdir::WalkDir;
 
+/// A directory-like container for graphs and nested namespaces. Graphs are
+/// addressed by path (e.g. `"team/project/graph"`), and every segment except
+/// the last is a namespace. Use to browse what's stored on the server without
+/// loading any graph data.
 #[derive(ResolvedObject, Clone, Ord, Eq, PartialEq, PartialOrd)]
 pub(crate) struct Namespace {
-    base_dir: PathBuf,
-    current_dir: PathBuf,
+    current_dir: PathBuf,  // always validated
+    relative_path: String, // relative to the root working directory
+}
+
+pub struct NamespaceIter {
+    it: walkdir::IntoIter,
+    root: Namespace,
+}
+
+impl Iterator for NamespaceIter {
+    type Item = NamespacedItem;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            match self.it.next() {
+                None => return None,
+                Some(Ok(entry)) => {
+                    let path = entry.path();
+                    if path.is_dir() {
+                        match get_relative_path(&self.root.current_dir, path) {
+                            Ok(relative) => {
+                                match self.root.try_new_child(&relative) {
+                                    Ok(child) => {
+                                        match &child {
+                                            NamespacedItem::Namespace(_) => {}
+                                            NamespacedItem::MetaGraph(_) => {
+                                                self.it.skip_current_dir() // graphs should not be traversed further
+                                            }
+                                        }
+                                        return Some(child);
+                                    }
+                                    Err(_) => {
+                                        self.it.skip_current_dir() // not a valid path
+                                    }
+                                }
+                            }
+                            Err(_) => {
+                                self.it.skip_current_dir() // not a valid path and shouldn't be traversed further}
+                            }
+                        }
+                    }
+                }
+                _ => {} // skip errors
+            };
+        }
+    }
 }
 
 impl Namespace {
-    pub fn new(base_dir: PathBuf, current_dir: PathBuf) -> Self {
+    pub fn root(root: PathBuf) -> Self {
         Self {
-            base_dir,
-            current_dir,
+            current_dir: root,
+            relative_path: "".to_owned(),
+        }
+    }
+
+    pub fn try_new(root: PathBuf, relative_path: String) -> Result<Self, PathValidationError> {
+        let current_dir = ValidPath::try_new(root, relative_path.as_str())?;
+        Self::try_from_valid(current_dir, &relative_path)
+    }
+
+    /// Create a namespace from a valid path if it exists and is a namespace
+    pub fn try_from_valid(
+        current_dir: ValidPath,
+        relative_path: impl Into<String>,
+    ) -> Result<Self, PathValidationError> {
+        if current_dir.is_namespace() {
+            Ok(Self {
+                current_dir: current_dir.into_path(),
+                relative_path: relative_path.into(),
+            })
+        } else {
+            Err(PathValidationError::NamespaceDoesNotExist(
+                relative_path.into(),
+            ))
         }
     }
 
-    fn get_all_children(&self) -> impl Iterator<Item = NamespacedItem> + use<'_> {
+    pub fn try_new_child(&self, file_name: &str) -> Result<NamespacedItem, PathValidationError> {
+        let current_dir = ValidPath::try_new(self.current_dir.clone(), file_name)?;
+        let relative_path = if self.relative_path.is_empty() {
+            file_name.to_owned()
+        } else {
+            [&self.relative_path, file_name].join("/")
+        };
+        let child = if current_dir.is_namespace() {
+            NamespacedItem::Namespace(Self::try_from_valid(current_dir, relative_path)?)
+        } else {
+            NamespacedItem::MetaGraph(MetaGraph::new(ExistingGraphFolder::try_from_valid(
+                current_dir,
+                &relative_path,
+            )?))
+        };
+        Ok(child)
+    }
+
+    /// Non-recursively list children
+    pub fn get_children(&self) -> impl Iterator<Item = NamespacedItem> + use<'_> {
         WalkDir::new(&self.current_dir)
+            .min_depth(1)
             .max_depth(1)
             .into_iter()
             .flatten()
             .filter_map(|entry| {
                 let path = entry.path();
-                let file_name = entry.file_name().to_str()?;
                 if path.is_dir() {
-                    if path != self.current_dir
-                        && valid_path(self.current_dir.clone(), file_name, true).is_ok()
-                    {
-                        Some(NamespacedItem::Namespace(Namespace::new(
-                            self.base_dir.clone(),
-                            path.to_path_buf(),
-                        )))
-                    } else {
-                        let base_path = self.base_dir.clone();
-                        let relative = get_relative_path(base_path.clone(), path, false).ok()?;
-                        let folder =
-                            ExistingGraphFolder::try_from(base_path.clone(), &relative).ok()?;
-                        Some(NamespacedItem::MetaGraph(MetaGraph::new(folder)))
-                    }
+                    let file_name = entry.file_name().to_str()?;
+                    self.try_new_child(file_name).ok()
                 } else {
                     None
                 }
             })
     }
 
-    pub(crate) fn get_all_namespaces(&self) -> Vec<Namespace> {
-        let base_path = self.base_dir.clone();
-        WalkDir::new(&self.current_dir)
-            .into_iter()
-            .filter_map(|e| {
-                let entry = e.ok()?;
-                let path = entry.path();
-                if path.is_dir() && get_relative_path(base_path.clone(), path, true).is_ok() {
-                    Some(Namespace::new(self.base_dir.clone(), path.to_path_buf()))
-                } else {
-                    None
-                }
-            })
-            .sorted()
-            .collect()
+    /// Recursively list all children
+    pub fn get_all_children(&self) -> impl Iterator<Item = NamespacedItem> {
+        let it = WalkDir::new(&self.current_dir).into_iter();
+        let root = self.clone();
+        NamespaceIter { it, root }
     }
 }
 
+fn is_graph_visible(
+    ctx: &Context<'_>,
+    policy: &Option<Arc<dyn AuthorizationPolicy>>,
+    g: &MetaGraph,
+) -> bool {
+    policy
+        .as_ref()
+        .map_or(true, |p| p.graph_permissions(ctx, &g.local_path()).is_ok())
+}
+
+fn is_namespace_visible(
+    ctx: &Context<'_>,
+    policy: &Option<Arc<dyn AuthorizationPolicy>>,
+    n: &Namespace,
+) -> bool {
+    policy.as_ref().map_or(true, |p| {
+        p.namespace_permissions(ctx, &n.relative_path) >= NamespacePermission::Discover
+    })
+}
+
 #[ResolvedObjectFields]
 impl Namespace {
-    async fn graphs(&self) -> GqlCollection<MetaGraph> {
+    /// Graphs directly inside this namespace (excludes graphs in nested
+    /// namespaces). Filtered by the caller's permissions — only graphs the
+    /// caller is allowed to see are returned.
+    async fn graphs(&self, ctx: &Context<'_>) -> GqlCollection<MetaGraph> {
+        let data = ctx.data_unchecked::<Data>();
         let self_clone = self.clone();
-        blocking_compute(move || {
-            GqlCollection::new(
-                self_clone
-                    .get_all_children()
-                    .into_iter()
-                    .filter_map(|g| match g {
-                        NamespacedItem::MetaGraph(g) => Some(g),
-                        NamespacedItem::Namespace(_) => None,
-                    })
-                    .sorted()
-                    .collect(),
-            )
-        })
-        .await
+        let items = blocking_compute(move || self_clone.get_children().collect::<Vec<_>>()).await;
+        GqlCollection::new(
+            items
+                .into_iter()
+                .filter_map(|item| match item {
+                    NamespacedItem::MetaGraph(g)
+                        if is_graph_visible(ctx, &data.auth_policy, &g) =>
+                    {
+                        Some(g)
+                    }
+                    _ => None,
+                })
+                .sorted()
+                .collect(),
+        )
     }
-    async fn path(&self) -> Result<String, InvalidPathReason> {
-        get_relative_path(self.base_dir.clone(), self.current_dir.as_path(), true)
+    /// Path of this namespace relative to the root namespace. Empty string for
+    /// the root namespace itself.
+    async fn path(&self) -> String {
+        self.relative_path.clone()
     }
 
+    /// Parent namespace, or null at the root.
     async fn parent(&self) -> Option<Namespace> {
-        let parent = self.current_dir.parent()?.to_path_buf();
-        if parent.starts_with(&self.base_dir) {
-            Some(Namespace::new(self.base_dir.clone(), parent))
-        } else {
+        if self.relative_path.is_empty() {
             None
+        } else {
+            let parent = self.current_dir.parent()?.to_path_buf();
+            let relative_path = self
+                .relative_path
+                .rsplit_once("/")
+                .map_or("", |(parent, _)| parent);
+            Some(Self {
+                current_dir: parent,
+                relative_path: relative_path.to_owned(),
+            })
         }
     }
 
-    async fn children(&self) -> GqlCollection<Namespace> {
+    /// Sub-namespaces directly inside this one (one level down, not recursive).
+    /// Filtered by permissions.
+    async fn children(&self, ctx: &Context<'_>) -> GqlCollection<Namespace> {
+        let data = ctx.data_unchecked::<Data>();
         let self_clone = self.clone();
-        blocking_compute(move || {
-            GqlCollection::new(
-                self_clone
-                    .get_all_children()
-                    .filter_map(|item| match item {
-                        NamespacedItem::MetaGraph(_) => None,
-                        NamespacedItem::Namespace(n) => Some(n),
-                    })
-                    .sorted()
-                    .collect(),
-            )
-        })
-        .await
+        let items = blocking_compute(move || self_clone.get_children().collect::<Vec<_>>()).await;
+        GqlCollection::new(
+            items
+                .into_iter()
+                .filter_map(|item| match item {
+                    NamespacedItem::Namespace(n)
+                        if is_namespace_visible(ctx, &data.auth_policy, &n) =>
+                    {
+                        Some(n)
+                    }
+                    _ => None,
+                })
+                .sorted()
+                .collect(),
+        )
     }
 
-    // Fetch the collection of namespaces/graphs in this namespace.
-    // Namespaces will be listed before graphs.
-    async fn items(&self) -> GqlCollection<NamespacedItem> {
+    /// Everything in this namespace — sub-namespaces and graphs — as a single
+    /// heterogeneous collection. Sub-namespaces are listed before graphs.
+    /// Filtered by permissions.
+    async fn items(&self, ctx: &Context<'_>) -> GqlCollection<NamespacedItem> {
+        let data = ctx.data_unchecked::<Data>();
         let self_clone = self.clone();
-        blocking_compute(move || {
-            GqlCollection::new(self_clone.get_all_children().sorted().collect())
-        })
-        .await
+        let all_items =
+            blocking_compute(move || self_clone.get_children().collect::<Vec<_>>()).await;
+        GqlCollection::new(
+            all_items
+                .into_iter()
+                .filter(|item| match item {
+                    NamespacedItem::MetaGraph(g) => is_graph_visible(ctx, &data.auth_policy, g),
+                    NamespacedItem::Namespace(n) => is_namespace_visible(ctx, &data.auth_policy, n),
+                })
+                .sorted()
+                .collect(),
+        )
     }
 }
diff --git a/raphtory-graphql/src/model/graph/namespaced_item.rs b/raphtory-graphql/src/model/graph/namespaced_item.rs
index 1f8e87bb13..8d315eebf7 100644
--- a/raphtory-graphql/src/model/graph/namespaced_item.rs
+++ b/raphtory-graphql/src/model/graph/namespaced_item.rs
@@ -5,7 +5,7 @@ use dynamic_graphql::Union;
 // This is useful for when fetching a collection of both for the purposes of displaying all such
 // items, paged.
 #[derive(Union, Clone, PartialOrd, PartialEq, Ord, Eq)]
-pub(crate) enum NamespacedItem {
+pub enum NamespacedItem {
     /// Namespace.
     Namespace(Namespace),
     /// Metagraph.
diff --git a/raphtory-graphql/src/model/graph/node.rs b/raphtory-graphql/src/model/graph/node.rs
index c21e19c54f..7b429480f5 100644
--- a/raphtory-graphql/src/model/graph/node.rs
+++ b/raphtory-graphql/src/model/graph/node.rs
@@ -3,6 +3,7 @@ use crate::{
         edges::GqlEdges,
         filtering::{GqlEdgeFilter, GqlNodeFilter, NodeViewCollection},
         history::GqlHistory,
+        node_id::GqlNodeId,
         nodes::GqlNodes,
         path_from_node::GqlPathFromNode,
         property::{GqlMetadata, GqlProperties},
@@ -53,9 +54,10 @@ impl<G: StaticGraphViewOps + IntoDynamic> From<NodeView<'static, G>> for GqlNode
 ///
 /// Collections can be filtered and used to create lists.
 impl GqlNode {
-    /// Returns the unique id of the node.
-    async fn id(&self) -> String {
-        self.vv.id().to_string()
+    /// Returns the unique id of the node — `String` for string-indexed
+    /// graphs, non-negative `Int` for integer-indexed graphs.
+    async fn id(&self) -> GqlNodeId {
+        GqlNodeId(self.vv.id())
     }
 
     /// Returns the name of the node.
@@ -73,24 +75,37 @@ impl GqlNode {
     }
 
     /// Return a view of node containing all layers specified.
-    async fn layers(&self, names: Vec<String>) -> GqlNode {
+
+    async fn layers(
+        &self,
+        #[graphql(desc = "Layer names to include.")] names: Vec<String>,
+    ) -> GqlNode {
         let self_clone = self.clone();
         blocking_compute(move || self_clone.vv.valid_layers(names).into()).await
     }
 
     /// Returns a collection containing nodes belonging to all layers except the excluded list of layers.
-    async fn exclude_layers(&self, names: Vec<String>) -> GqlNode {
+
+    async fn exclude_layers(
+        &self,
+        #[graphql(desc = "Layer names to exclude.")] names: Vec<String>,
+    ) -> GqlNode {
         let self_clone = self.clone();
         blocking_compute(move || self_clone.vv.exclude_valid_layers(names).into()).await
     }
 
     /// Returns a collection containing nodes belonging to the specified layer.
-    async fn layer(&self, name: String) -> GqlNode {
+
+    async fn layer(&self, #[graphql(desc = "Layer name to include.")] name: String) -> GqlNode {
         self.vv.valid_layers(name).into()
     }
 
     /// Returns a collection containing nodes belonging to all layers except the excluded layer.
-    async fn exclude_layer(&self, name: String) -> GqlNode {
+
+    async fn exclude_layer(
+        &self,
+        #[graphql(desc = "Layer name to exclude.")] name: String,
+    ) -> GqlNode {
         self.vv.exclude_valid_layers(name).into()
     }
 
@@ -103,10 +118,20 @@ impl GqlNode {
     /// e.g. "1 month and 1 day" will align at the start of the day.
     /// Note that passing a step larger than window while alignment_unit is not "Unaligned" may lead to some entries appearing before
     /// the start of the first window and/or after the end of the last window (i.e. not included in any window).
+
     async fn rolling(
         &self,
+        #[graphql(
+            desc = "Width of each window. Pass either `{epoch: <ms>}` for a discrete number of milliseconds (e.g. `{epoch: 1000}` for 1 second), or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}` or `{duration: 2 hours and 30 minutes}`)."
+        )]
         window: WindowDuration,
+        #[graphql(
+            desc = "Optional gap between the start of one window and the start of the next. Accepts the same `{epoch: <ms>}` or `{duration: <text>}` values as `window`. Defaults to `window` — i.e. windows touch end-to-end with no overlap and no gap."
+        )]
         step: Option<WindowDuration>,
+        #[graphql(
+            desc = "Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step` (or `window` if no step is set)."
+        )]
         alignment_unit: Option<GqlAlignmentUnit>,
     ) -> Result<GqlNodeWindowSet, GraphError> {
         let window = window.try_into_interval()?;
@@ -126,9 +151,16 @@ impl GqlNode {
     /// alignment_unit optionally aligns the windows to the specified unit. "Unaligned" can be passed for no alignment.
     /// If unspecified (i.e. by default), alignment is done on the smallest unit of time in the step.
     /// e.g. "1 month and 1 day" will align at the start of the day.
+
     async fn expanding(
         &self,
+        #[graphql(
+            desc = "How much the window grows by on each step. Pass either `{epoch: <ms>}` for a discrete number of milliseconds, or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}`)."
+        )]
         step: WindowDuration,
+        #[graphql(
+            desc = "Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step`."
+        )]
         alignment_unit: Option<GqlAlignmentUnit>,
     ) -> Result<GqlNodeWindowSet, GraphError> {
         let step = step.try_into_interval()?;
@@ -141,12 +173,21 @@ impl GqlNode {
     }
 
     /// Create a view of the node including all events between the specified start (inclusive) and end (exclusive).
-    async fn window(&self, start: GqlTimeInput, end: GqlTimeInput) -> GqlNode {
+
+    async fn window(
+        &self,
+        #[graphql(desc = "Inclusive lower bound.")] start: GqlTimeInput,
+        #[graphql(desc = "Exclusive upper bound.")] end: GqlTimeInput,
+    ) -> GqlNode {
         self.vv.window(start.into_time(), end.into_time()).into()
     }
 
     /// Create a view of the node including all events at a specified time.
-    async fn at(&self, time: GqlTimeInput) -> GqlNode {
+
+    async fn at(
+        &self,
+        #[graphql(desc = "Instant to pin the view to.")] time: GqlTimeInput,
+    ) -> GqlNode {
         self.vv.at(time.into_time()).into()
     }
 
@@ -157,7 +198,11 @@ impl GqlNode {
     }
 
     /// Create a view of the node including all events that are valid at the specified time.
-    async fn snapshot_at(&self, time: GqlTimeInput) -> GqlNode {
+
+    async fn snapshot_at(
+        &self,
+        #[graphql(desc = "Instant at which entities must be valid.")] time: GqlTimeInput,
+    ) -> GqlNode {
         self.vv.snapshot_at(time.into_time()).into()
     }
 
@@ -168,29 +213,54 @@ impl GqlNode {
     }
 
     /// Create a view of the node including all events before specified end time (exclusive).
-    async fn before(&self, time: GqlTimeInput) -> GqlNode {
+
+    async fn before(
+        &self,
+        #[graphql(desc = "Exclusive upper bound.")] time: GqlTimeInput,
+    ) -> GqlNode {
         self.vv.before(time.into_time()).into()
     }
 
     /// Create a view of the node including all events after the specified start time (exclusive).
-    async fn after(&self, time: GqlTimeInput) -> GqlNode {
+
+    async fn after(
+        &self,
+        #[graphql(desc = "Exclusive lower bound.")] time: GqlTimeInput,
+    ) -> GqlNode {
         self.vv.after(time.into_time()).into()
     }
 
     /// Shrink a Window to a specified start and end time, if these are earlier and later than the current start and end respectively.
-    async fn shrink_window(&self, start: GqlTimeInput, end: GqlTimeInput) -> Self {
+
+    async fn shrink_window(
+        &self,
+        #[graphql(desc = "Proposed new start (TimeInput); ignored if it would widen the window.")]
+        start: GqlTimeInput,
+        #[graphql(desc = "Proposed new end (TimeInput); ignored if it would widen the window.")]
+        end: GqlTimeInput,
+    ) -> Self {
         self.vv
             .shrink_window(start.into_time(), end.into_time())
             .into()
     }
 
     /// Set the start of the window to the larger of a specified start time and self.start().
-    async fn shrink_start(&self, start: GqlTimeInput) -> Self {
+
+    async fn shrink_start(
+        &self,
+        #[graphql(desc = "Proposed new start (TimeInput); ignored if it would widen the window.")]
+        start: GqlTimeInput,
+    ) -> Self {
         self.vv.shrink_start(start.into_time()).into()
     }
 
     /// Set the end of the window to the smaller of a specified end and self.end().
-    async fn shrink_end(&self, end: GqlTimeInput) -> Self {
+
+    async fn shrink_end(
+        &self,
+        #[graphql(desc = "Proposed new end (TimeInput); ignored if it would widen the window.")]
+        end: GqlTimeInput,
+    ) -> Self {
         self.vv.shrink_end(end.into_time()).into()
     }
 
diff --git a/raphtory-graphql/src/model/graph/node_id.rs b/raphtory-graphql/src/model/graph/node_id.rs
new file mode 100644
index 0000000000..911e779aa8
--- /dev/null
+++ b/raphtory-graphql/src/model/graph/node_id.rs
@@ -0,0 +1,76 @@
+use async_graphql::{Error, Value as GqlValue};
+use dynamic_graphql::{Scalar, ScalarValue};
+use raphtory::core::entities::nodes::node_ref::{AsNodeRef, NodeRef};
+use raphtory_api::core::entities::GID;
+use serde::{Deserialize, Serialize};
+use serde_json::Number;
+
+/// Identifier for a node — either a string (`"alice"`) or a non-negative
+/// integer (`42`). Use whichever form matches how the graph was indexed
+/// when nodes were added.
+#[derive(Scalar, Clone, Debug, Serialize, Deserialize)]
+#[graphql(name = "NodeId")]
+pub struct GqlNodeId(pub GID);
+
+impl ScalarValue for GqlNodeId {
+    fn from_value(value: GqlValue) -> Result<Self, Error> {
+        match value {
+            GqlValue::String(s) => Ok(GqlNodeId(GID::Str(s))),
+            GqlValue::Number(n) => n
+                .as_u64()
+                .map(|u| GqlNodeId(GID::U64(u)))
+                .ok_or_else(|| Error::new("NodeId integer must be a non-negative Int.")),
+            _ => Err(Error::new(
+                "Expected NodeId as a String or non-negative Int.",
+            )),
+        }
+    }
+
+    fn to_value(&self) -> GqlValue {
+        match &self.0 {
+            GID::Str(s) => GqlValue::String(s.clone()),
+            GID::U64(u) => GqlValue::Number(Number::from(*u)),
+        }
+    }
+}
+
+impl From<GqlNodeId> for GID {
+    fn from(value: GqlNodeId) -> GID {
+        value.0
+    }
+}
+
+impl From<&str> for GqlNodeId {
+    fn from(value: &str) -> Self {
+        GqlNodeId(GID::Str(value.to_owned()))
+    }
+}
+
+impl From<String> for GqlNodeId {
+    fn from(value: String) -> Self {
+        GqlNodeId(GID::Str(value))
+    }
+}
+
+impl From<u64> for GqlNodeId {
+    fn from(value: u64) -> Self {
+        GqlNodeId(GID::U64(value))
+    }
+}
+
+impl AsNodeRef for GqlNodeId {
+    fn as_node_ref(&self) -> NodeRef<'_> {
+        self.0.as_node_ref()
+    }
+}
+
+impl GqlNodeId {
+    /// Returns the id as a `String`. Integer ids are formatted as decimal.
+    /// Useful for callers that need a string id.
+    pub fn to_string(&self) -> String {
+        match &self.0 {
+            GID::Str(s) => s.clone(),
+            GID::U64(u) => u.to_string(),
+        }
+    }
+}
diff --git a/raphtory-graphql/src/model/graph/nodes.rs b/raphtory-graphql/src/model/graph/nodes.rs
index 82fa5a5077..515f6a0c12 100644
--- a/raphtory-graphql/src/model/graph/nodes.rs
+++ b/raphtory-graphql/src/model/graph/nodes.rs
@@ -1,6 +1,7 @@
 use crate::{
     model::{
         graph::{
+            collection::{check_list_allowed, check_page_limit},
             filtering::{GqlNodeFilter, NodesViewCollection},
             node::GqlNode,
             timeindex::{GqlEventTime, GqlTimeInput},
@@ -11,6 +12,7 @@ use crate::{
     },
     rayon::blocking_compute,
 };
+use async_graphql::{Context, Result};
 use dynamic_graphql::{ResolvedObject, ResolvedObjectFields};
 use itertools::Itertools;
 use raphtory::{
@@ -31,6 +33,9 @@ use raphtory::{
 use raphtory_api::core::{entities::VID, utils::time::IntoTime};
 use std::cmp::Ordering;
 
+/// A lazy collection of nodes from a graph view. Supports all the same view
+/// transforms as `Graph` (window, layer, filter, ...) plus pagination and
+/// sorting. Iterated via `list` / `page` / `ids` / `count`.
 #[derive(ResolvedObject, Clone)]
 #[graphql(name = "Nodes")]
 pub(crate) struct GqlNodes {
@@ -68,23 +73,36 @@ impl GqlNodes {
     }
 
     /// Return a view of the nodes containing all layers specified.
-    async fn layers(&self, names: Vec<String>) -> Self {
+
+    async fn layers(
+        &self,
+        #[graphql(desc = "Layer names to include.")] names: Vec<String>,
+    ) -> Self {
         self.update(self.nn.valid_layers(names))
     }
 
     /// Return a view of the nodes containing all layers except those specified.
-    async fn exclude_layers(&self, names: Vec<String>) -> Self {
+
+    async fn exclude_layers(
+        &self,
+        #[graphql(desc = "Layer names to exclude.")] names: Vec<String>,
+    ) -> Self {
         let self_clone = self.clone();
         blocking_compute(move || self_clone.update(self_clone.nn.exclude_valid_layers(names))).await
     }
 
     /// Return a view of the nodes containing the specified layer.
-    async fn layer(&self, name: String) -> Self {
+
+    async fn layer(&self, #[graphql(desc = "Layer name to include.")] name: String) -> Self {
         self.update(self.nn.valid_layers(name))
     }
 
     /// Return a view of the nodes containing all layers except those specified.
-    async fn exclude_layer(&self, name: String) -> Self {
+
+    async fn exclude_layer(
+        &self,
+        #[graphql(desc = "Layer name to exclude.")] name: String,
+    ) -> Self {
         self.update(self.nn.exclude_valid_layers(name))
     }
 
@@ -97,10 +115,20 @@ impl GqlNodes {
     /// e.g. "1 month and 1 day" will align at the start of the day.
     /// Note that passing a step larger than window while alignment_unit is not "Unaligned" may lead to some entries appearing before
     /// the start of the first window and/or after the end of the last window (i.e. not included in any window).
+
     async fn rolling(
         &self,
+        #[graphql(
+            desc = "Width of each window. Pass either `{epoch: <ms>}` for a discrete number of milliseconds (e.g. `{epoch: 1000}` for 1 second), or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}` or `{duration: 2 hours and 30 minutes}`)."
+        )]
         window: WindowDuration,
+        #[graphql(
+            desc = "Optional gap between the start of one window and the start of the next. Accepts the same `{epoch: <ms>}` or `{duration: <text>}` values as `window`. Defaults to `window` — i.e. windows touch end-to-end with no overlap and no gap."
+        )]
         step: Option<WindowDuration>,
+        #[graphql(
+            desc = "Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step` (or `window` if no step is set)."
+        )]
         alignment_unit: Option<GqlAlignmentUnit>,
     ) -> Result<GqlNodesWindowSet, GraphError> {
         let window = window.try_into_interval()?;
@@ -120,9 +148,16 @@ impl GqlNodes {
     /// alignment_unit optionally aligns the windows to the specified unit. "Unaligned" can be passed for no alignment.
     /// If unspecified (i.e. by default), alignment is done on the smallest unit of time in the step.
     /// e.g. "1 month and 1 day" will align at the start of the day.
+
     async fn expanding(
         &self,
+        #[graphql(
+            desc = "How much the window grows by on each step. Pass either `{epoch: <ms>}` for a discrete number of milliseconds, or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}`)."
+        )]
         step: WindowDuration,
+        #[graphql(
+            desc = "Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step`."
+        )]
         alignment_unit: Option<GqlAlignmentUnit>,
     ) -> Result<GqlNodesWindowSet, GraphError> {
         let step = step.try_into_interval()?;
@@ -135,12 +170,21 @@ impl GqlNodes {
     }
 
     /// Create a view of the node including all events between the specified start (inclusive) and end (exclusive).
-    async fn window(&self, start: GqlTimeInput, end: GqlTimeInput) -> Self {
+
+    async fn window(
+        &self,
+        #[graphql(desc = "Inclusive lower bound.")] start: GqlTimeInput,
+        #[graphql(desc = "Exclusive upper bound.")] end: GqlTimeInput,
+    ) -> Self {
         self.update(self.nn.window(start.into_time(), end.into_time()))
     }
 
     /// Create a view of the nodes including all events at a specified time.
-    async fn at(&self, time: GqlTimeInput) -> Self {
+
+    async fn at(
+        &self,
+        #[graphql(desc = "Instant to pin the view to.")] time: GqlTimeInput,
+    ) -> Self {
         self.update(self.nn.at(time.into_time()))
     }
 
@@ -151,7 +195,11 @@ impl GqlNodes {
     }
 
     /// Create a view of the nodes including all events that are valid at the specified time.
-    async fn snapshot_at(&self, time: GqlTimeInput) -> Self {
+
+    async fn snapshot_at(
+        &self,
+        #[graphql(desc = "Instant at which entities must be valid.")] time: GqlTimeInput,
+    ) -> Self {
         self.update(self.nn.snapshot_at(time.into_time()))
     }
 
@@ -162,37 +210,70 @@ impl GqlNodes {
     }
 
     /// Create a view of the nodes including all events before specified end time (exclusive).
-    async fn before(&self, time: GqlTimeInput) -> Self {
+
+    async fn before(&self, #[graphql(desc = "Exclusive upper bound.")] time: GqlTimeInput) -> Self {
         self.update(self.nn.before(time.into_time()))
     }
 
     /// Create a view of the nodes including all events after the specified start time (exclusive).
-    async fn after(&self, time: GqlTimeInput) -> Self {
+
+    async fn after(&self, #[graphql(desc = "Exclusive lower bound.")] time: GqlTimeInput) -> Self {
         self.update(self.nn.after(time.into_time()))
     }
 
     /// Shrink both the start and end of the window.
-    async fn shrink_window(&self, start: GqlTimeInput, end: GqlTimeInput) -> Self {
+
+    async fn shrink_window(
+        &self,
+        #[graphql(desc = "Proposed new start (TimeInput); ignored if it would widen the window.")]
+        start: GqlTimeInput,
+        #[graphql(desc = "Proposed new end (TimeInput); ignored if it would widen the window.")]
+        end: GqlTimeInput,
+    ) -> Self {
         self.update(self.nn.shrink_window(start.into_time(), end.into_time()))
     }
 
     /// Set the start of the window to the larger of a specified start time and self.start().
-    async fn shrink_start(&self, start: GqlTimeInput) -> Self {
+
+    async fn shrink_start(
+        &self,
+        #[graphql(desc = "Proposed new start (TimeInput); ignored if it would widen the window.")]
+        start: GqlTimeInput,
+    ) -> Self {
         self.update(self.nn.shrink_start(start.into_time()))
     }
 
     /// Set the end of the window to the smaller of a specified end and self.end().
-    async fn shrink_end(&self, end: GqlTimeInput) -> Self {
+
+    async fn shrink_end(
+        &self,
+        #[graphql(desc = "Proposed new end (TimeInput); ignored if it would widen the window.")]
+        end: GqlTimeInput,
+    ) -> Self {
         self.update(self.nn.shrink_end(end.into_time()))
     }
 
     /// Filter nodes by node type.
-    async fn type_filter(&self, node_types: Vec<String>) -> Self {
+
+    async fn type_filter(
+        &self,
+        #[graphql(desc = "Node-type names to keep.")] node_types: Vec<String>,
+    ) -> Self {
         let self_clone = self.clone();
         blocking_compute(move || self_clone.update(self_clone.nn.type_filter(&node_types))).await
     }
 
-    async fn apply_views(&self, views: Vec<NodesViewCollection>) -> Result<GqlNodes, GraphError> {
+    /// Apply a list of views in the given order and return the resulting nodes
+    /// collection. Lets callers compose window, layer, filter, and snapshot
+    /// operations in a single call.
+
+    async fn apply_views(
+        &self,
+        #[graphql(
+            desc = "Ordered list of view operations; each entry is a one-of variant (`window`, `layer`, `filter`, etc.) applied to the running result."
+        )]
+        views: Vec<NodesViewCollection>,
+    ) -> Result<GqlNodes, GraphError> {
         let mut return_view: GqlNodes = GqlNodes::new(self.nn.clone());
         for view in views {
             return_view = match view {
@@ -248,7 +329,16 @@ impl GqlNodes {
     //// Sorting ////
     /////////////////
 
-    async fn sorted(&self, sort_bys: Vec<NodeSortBy>) -> Self {
+    /// Sort the nodes. Multiple criteria are applied lexicographically (ties on the
+    /// first key break to the second, etc.).
+
+    async fn sorted(
+        &self,
+        #[graphql(
+            desc = "Ordered list of sort keys. Each entry chooses exactly one of `id` / `time` / `property`, with an optional `reverse: true` to flip order."
+        )]
+        sort_bys: Vec<NodeSortBy>,
+    ) -> Self {
         let self_clone = self.clone();
         blocking_compute(move || {
             let sorted: Index<VID> = self_clone
@@ -318,6 +408,7 @@ impl GqlNodes {
     //// List ///////
     /////////////////
 
+    /// Number of nodes in the current view.
     async fn count(&self) -> usize {
         let self_clone = self.clone();
         blocking_compute(move || self_clone.nn.len()).await
@@ -328,33 +419,66 @@ impl GqlNodes {
     ///
     /// For example, if page(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
     /// will be returned.
+
     async fn page(
         &self,
-        limit: usize,
+        ctx: &Context<'_>,
+        #[graphql(desc = "Maximum number of items to return on this page.")] limit: usize,
+        #[graphql(desc = "Extra items to skip on top of `pageIndex` paging (default 0).")]
         offset: Option<usize>,
+        #[graphql(
+            desc = "Zero-based page number; multiplies `limit` to determine where to start (default 0)."
+        )]
         page_index: Option<usize>,
-    ) -> Vec<GqlNode> {
+    ) -> Result<Vec<GqlNode>> {
+        check_page_limit(ctx, limit)?;
         let self_clone = self.clone();
-        blocking_compute(move || {
+        Ok(blocking_compute(move || {
             let start = page_index.unwrap_or(0) * limit + offset.unwrap_or(0);
             self_clone.iter().skip(start).take(limit).collect()
         })
-        .await
+        .await)
     }
 
-    async fn list(&self) -> Vec<GqlNode> {
+    /// Materialise every node in the view. Rejected by the server when bulk list
+    /// endpoints are disabled; use `page` for paginated access instead.
+    async fn list(&self, ctx: &Context<'_>) -> Result<Vec<GqlNode>> {
+        check_list_allowed(ctx)?;
         let self_clone = self.clone();
-        blocking_compute(move || self_clone.iter().collect()).await
+        Ok(blocking_compute(move || self_clone.iter().collect()).await)
     }
 
-    /// Returns a view of the node ids.
-    async fn ids(&self) -> Vec<String> {
+    /// Every node's id (name) as a flat list of strings. Rejected by the server when
+    /// bulk list endpoints are disabled.
+    async fn ids(&self, ctx: &Context<'_>) -> Result<Vec<String>> {
+        check_list_allowed(ctx)?;
         let self_clone = self.clone();
-        blocking_compute(move || self_clone.nn.iter_unlocked().map(|nn| nn.name()).collect()).await
+        Ok(
+            blocking_compute(move || self_clone.nn.iter_unlocked().map(|nn| nn.name()).collect())
+                .await,
+        )
     }
 
-    /// Returns a filtered view that applies to list down the chain
-    async fn filter(&self, expr: GqlNodeFilter) -> Result<Self, GraphError> {
+    /// Narrow the collection to nodes matching `expr`. The filter sticks to the
+    /// returned view — every subsequent traversal through these nodes (their
+    /// neighbours, edges, properties) continues to see the filtered scope.
+    ///
+    /// Useful when you want one scoping rule to apply across the whole query.
+    /// E.g. restricting everything to a specific week:
+    ///
+    /// ```text
+    /// nodes { filter(expr: {window: {start: 1234, end: 5678}}) {
+    ///   list { neighbours { list { name } } }   # neighbours still windowed
+    /// } }
+    /// ```
+    ///
+    /// Contrast with `select`, which applies here and is not carried through.
+
+    async fn filter(
+        &self,
+        #[graphql(desc = "Composite node filter (by name, property, type, etc.).")]
+        expr: GqlNodeFilter,
+    ) -> Result<Self, GraphError> {
         let self_clone = self.clone();
         blocking_compute(move || {
             let filter: CompositeNodeFilter = expr.try_into()?;
@@ -364,8 +488,30 @@ impl GqlNodes {
         .await
     }
 
-    /// Returns filtered list of nodes
-    async fn select(&self, expr: GqlNodeFilter) -> Result<Self, GraphError> {
+    /// Narrow the collection to nodes matching `expr`, but only at this step —
+    /// subsequent traversals out of these nodes see the unfiltered graph again.
+    ///
+    /// Useful when you want different scopes at different hops. E.g. nodes
+    /// active on Monday, then their neighbours active on Tuesday, then *those*
+    /// neighbours active on Wednesday:
+    ///
+    /// ```text
+    /// nodes { select(expr: {window: {...monday...}}) {
+    ///   list { neighbours { select(expr: {window: {...tuesday...}}) {
+    ///     list { neighbours { select(expr: {window: {...wednesday...}}) {
+    ///       list { name }
+    ///     } } }
+    ///   } } }
+    /// } }
+    /// ```
+    ///
+    /// Contrast with `filter`, which persists the scope through subsequent ops.
+
+    async fn select(
+        &self,
+        #[graphql(desc = "Composite node filter (by name, property, type, etc.).")]
+        expr: GqlNodeFilter,
+    ) -> Result<Self, GraphError> {
         let self_clone = self.clone();
         blocking_compute(move || {
             let filter: CompositeNodeFilter = expr.try_into()?;
diff --git a/raphtory-graphql/src/model/graph/path_from_node.rs b/raphtory-graphql/src/model/graph/path_from_node.rs
index e4562fea23..4a41c4a573 100644
--- a/raphtory-graphql/src/model/graph/path_from_node.rs
+++ b/raphtory-graphql/src/model/graph/path_from_node.rs
@@ -1,5 +1,6 @@
 use crate::{
     model::graph::{
+        collection::{check_list_allowed, check_page_limit},
         filtering::{GqlNodeFilter, PathFromNodeViewCollection},
         node::GqlNode,
         timeindex::{GqlEventTime, GqlTimeInput},
@@ -8,6 +9,7 @@ use crate::{
     },
     rayon::blocking_compute,
 };
+use async_graphql::Context;
 use dynamic_graphql::{ResolvedObject, ResolvedObjectFields};
 use raphtory::{
     core::utils::time::TryIntoInterval,
@@ -20,6 +22,10 @@ use raphtory::{
 };
 use raphtory_api::core::utils::time::IntoTime;
 
+/// A collection of nodes anchored to a source node — the result of traversals
+/// like `node.neighbours`, `inNeighbours`, or `outNeighbours`. Supports all
+/// the usual view transforms (window, layer, filter, ...) and can be chained
+/// to walk further hops.
 #[derive(ResolvedObject, Clone)]
 #[graphql(name = "PathFromNode")]
 pub(crate) struct GqlPathFromNode {
@@ -50,24 +56,37 @@ impl GqlPathFromNode {
     ////////////////////////
 
     /// Returns a view of PathFromNode containing the specified layer, errors if the layer does not exist.
-    async fn layers(&self, names: Vec<String>) -> Self {
+
+    async fn layers(
+        &self,
+        #[graphql(desc = "Layer names to include.")] names: Vec<String>,
+    ) -> Self {
         let self_clone = self.clone();
         blocking_compute(move || self_clone.update(self_clone.nn.valid_layers(names))).await
     }
 
     /// Return a view of PathFromNode containing all layers except the specified excluded layers, errors if any of the layers do not exist.
-    async fn exclude_layers(&self, names: Vec<String>) -> Self {
+
+    async fn exclude_layers(
+        &self,
+        #[graphql(desc = "Layer names to exclude.")] names: Vec<String>,
+    ) -> Self {
         let self_clone = self.clone();
         blocking_compute(move || self_clone.update(self_clone.nn.exclude_valid_layers(names))).await
     }
 
     /// Return a view of PathFromNode containing the layer specified layer, errors if the layer does not exist.
-    async fn layer(&self, name: String) -> Self {
+
+    async fn layer(&self, #[graphql(desc = "Layer name to include.")] name: String) -> Self {
         self.update(self.nn.valid_layers(name))
     }
 
     /// Return a view of PathFromNode containing all layers except the specified excluded layers, errors if any of the layers do not exist.
-    async fn exclude_layer(&self, name: String) -> Self {
+
+    async fn exclude_layer(
+        &self,
+        #[graphql(desc = "Layer name to exclude.")] name: String,
+    ) -> Self {
         self.update(self.nn.exclude_valid_layers(name))
     }
 
@@ -80,10 +99,20 @@ impl GqlPathFromNode {
     /// e.g. "1 month and 1 day" will align at the start of the day.
     /// Note that passing a step larger than window while alignment_unit is not "Unaligned" may lead to some entries appearing before
     /// the start of the first window and/or after the end of the last window (i.e. not included in any window).
+
     async fn rolling(
         &self,
+        #[graphql(
+            desc = "Width of each window. Pass either `{epoch: <ms>}` for a discrete number of milliseconds (e.g. `{epoch: 1000}` for 1 second), or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}` or `{duration: 2 hours and 30 minutes}`)."
+        )]
         window: WindowDuration,
+        #[graphql(
+            desc = "Optional gap between the start of one window and the start of the next. Accepts the same `{epoch: <ms>}` or `{duration: <text>}` values as `window`. Defaults to `window` — i.e. windows touch end-to-end with no overlap and no gap."
+        )]
         step: Option<WindowDuration>,
+        #[graphql(
+            desc = "Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step` (or `window` if no step is set)."
+        )]
         alignment_unit: Option<GqlAlignmentUnit>,
     ) -> Result<GqlPathFromNodeWindowSet, GraphError> {
         let window = window.try_into_interval()?;
@@ -103,9 +132,16 @@ impl GqlPathFromNode {
     /// alignment_unit optionally aligns the windows to the specified unit. "Unaligned" can be passed for no alignment.
     /// If unspecified (i.e. by default), alignment is done on the smallest unit of time in the step.
     /// e.g. "1 month and 1 day" will align at the start of the day.
+
     async fn expanding(
         &self,
+        #[graphql(
+            desc = "How much the window grows by on each step. Pass either `{epoch: <ms>}` for a discrete number of milliseconds, or `{duration: <text>}` for a calendar duration (e.g. `{duration: 1 day}`)."
+        )]
         step: WindowDuration,
+        #[graphql(
+            desc = "Optional anchor for window boundaries — pass `Unaligned` to disable, or one of the unit values (e.g. `Day`, `Hour`, `Minute`) to align edges to that calendar unit. Defaults to the smallest unit present in `step`."
+        )]
         alignment_unit: Option<GqlAlignmentUnit>,
     ) -> Result<GqlPathFromNodeWindowSet, GraphError> {
         let step = step.try_into_interval()?;
@@ -118,12 +154,21 @@ impl GqlPathFromNode {
     }
 
     /// Create a view of the PathFromNode including all events between a specified start (inclusive) and end (exclusive).
-    async fn window(&self, start: GqlTimeInput, end: GqlTimeInput) -> Self {
+
+    async fn window(
+        &self,
+        #[graphql(desc = "Inclusive lower bound.")] start: GqlTimeInput,
+        #[graphql(desc = "Exclusive upper bound.")] end: GqlTimeInput,
+    ) -> Self {
         self.update(self.nn.window(start.into_time(), end.into_time()))
     }
 
     /// Create a view of the PathFromNode including all events at time.
-    async fn at(&self, time: GqlTimeInput) -> Self {
+
+    async fn at(
+        &self,
+        #[graphql(desc = "Instant to pin the view to.")] time: GqlTimeInput,
+    ) -> Self {
         self.update(self.nn.at(time.into_time()))
     }
 
@@ -134,7 +179,11 @@ impl GqlPathFromNode {
     }
 
     /// Create a view of the PathFromNode including all events that are valid at the specified time.
-    async fn snapshot_at(&self, time: GqlTimeInput) -> Self {
+
+    async fn snapshot_at(
+        &self,
+        #[graphql(desc = "Instant at which entities must be valid.")] time: GqlTimeInput,
+    ) -> Self {
         self.update(self.nn.snapshot_at(time.into_time()))
     }
 
@@ -145,32 +194,55 @@ impl GqlPathFromNode {
     }
 
     /// Create a view of the PathFromNode including all events before the specified end (exclusive).
-    async fn before(&self, time: GqlTimeInput) -> Self {
+
+    async fn before(&self, #[graphql(desc = "Exclusive upper bound.")] time: GqlTimeInput) -> Self {
         self.update(self.nn.before(time.into_time()))
     }
 
     /// Create a view of the PathFromNode including all events after the specified start (exclusive).
-    async fn after(&self, time: GqlTimeInput) -> Self {
+
+    async fn after(&self, #[graphql(desc = "Exclusive lower bound.")] time: GqlTimeInput) -> Self {
         self.update(self.nn.after(time.into_time()))
     }
 
     /// Shrink both the start and end of the window.
-    async fn shrink_window(&self, start: GqlTimeInput, end: GqlTimeInput) -> Self {
+
+    async fn shrink_window(
+        &self,
+        #[graphql(desc = "Proposed new start (TimeInput); ignored if it would widen the window.")]
+        start: GqlTimeInput,
+        #[graphql(desc = "Proposed new end (TimeInput); ignored if it would widen the window.")]
+        end: GqlTimeInput,
+    ) -> Self {
         self.update(self.nn.shrink_window(start.into_time(), end.into_time()))
     }
 
     /// Set the start of the window to the larger of the specified start and self.start().
-    async fn shrink_start(&self, start: GqlTimeInput) -> Self {
+
+    async fn shrink_start(
+        &self,
+        #[graphql(desc = "Proposed new start (TimeInput); ignored if it would widen the window.")]
+        start: GqlTimeInput,
+    ) -> Self {
         self.update(self.nn.shrink_start(start.into_time()))
     }
 
     /// Set the end of the window to the smaller of the specified end and self.end().
-    async fn shrink_end(&self, end: GqlTimeInput) -> Self {
+
+    async fn shrink_end(
+        &self,
+        #[graphql(desc = "Proposed new end (TimeInput); ignored if it would widen the window.")]
+        end: GqlTimeInput,
+    ) -> Self {
         self.update(self.nn.shrink_end(end.into_time()))
     }
 
-    /// Filter nodes by type.
-    async fn type_filter(&self, node_types: Vec<String>) -> Self {
+    /// Narrow this path to neighbours whose node type is in the given set.
+
+    async fn type_filter(
+        &self,
+        #[graphql(desc = "Node types to keep.")] node_types: Vec<String>,
+    ) -> Self {
         let self_clone = self.clone();
         blocking_compute(move || self_clone.update(self_clone.nn.type_filter(&node_types))).await
     }
@@ -193,6 +265,7 @@ impl GqlPathFromNode {
     //// List ///////
     /////////////////
 
+    /// Number of neighbour nodes reachable from the source in this view.
     async fn count(&self) -> usize {
         let self_clone = self.clone();
         blocking_compute(move || self_clone.nn.len()).await
@@ -203,34 +276,50 @@ impl GqlPathFromNode {
     ///
     /// For example, if page(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
     /// will be returned.
+
     async fn page(
         &self,
-        limit: usize,
+        ctx: &Context<'_>,
+        #[graphql(desc = "Maximum number of items to return on this page.")] limit: usize,
+        #[graphql(desc = "Extra items to skip on top of `pageIndex` paging (default 0).")]
         offset: Option<usize>,
+        #[graphql(
+            desc = "Zero-based page number; multiplies `limit` to determine where to start (default 0)."
+        )]
         page_index: Option<usize>,
-    ) -> Vec<GqlNode> {
+    ) -> async_graphql::Result<Vec<GqlNode>> {
+        check_page_limit(ctx, limit)?;
         let self_clone = self.clone();
-        blocking_compute(move || {
+        Ok(blocking_compute(move || {
             let start = page_index.unwrap_or(0) * limit + offset.unwrap_or(0);
             self_clone.iter().skip(start).take(limit).collect()
         })
-        .await
+        .await)
     }
 
-    async fn list(&self) -> Vec<GqlNode> {
+    /// Materialise every neighbour node in the path. Rejected by the server when
+    /// bulk list endpoints are disabled; use `page` for paginated access instead.
+    async fn list(&self, ctx: &Context<'_>) -> async_graphql::Result<Vec<GqlNode>> {
+        check_list_allowed(ctx)?;
         let self_clone = self.clone();
-        blocking_compute(move || self_clone.iter().collect()).await
+        Ok(blocking_compute(move || self_clone.iter().collect()).await)
     }
 
-    /// Returns the node ids.
-    async fn ids(&self) -> Vec<String> {
+    /// Every neighbour node's id (name) as a flat list of strings. Rejected by the
+    /// server when bulk list endpoints are disabled.
+    async fn ids(&self, ctx: &Context<'_>) -> async_graphql::Result<Vec<String>> {
+        check_list_allowed(ctx)?;
         let self_clone = self.clone();
-        blocking_compute(move || self_clone.nn.name().collect()).await
+        Ok(blocking_compute(move || self_clone.nn.name().collect()).await)
     }
 
     /// Takes a specified selection of views and applies them in given order.
+
     async fn apply_views(
         &self,
+        #[graphql(
+            desc = "Ordered list of view operations; each entry is a one-of variant (`window`, `layer`, `filter`, ...) applied to the running result."
+        )]
         views: Vec<PathFromNodeViewCollection>,
     ) -> Result<GqlPathFromNode, GraphError> {
         let mut return_view: GqlPathFromNode = self.clone();
@@ -276,8 +365,26 @@ impl GqlPathFromNode {
         Ok(return_view)
     }
 
-    /// Returns a filtered view that applies to list down the chain
-    async fn filter(&self, expr: GqlNodeFilter) -> Result<Self, GraphError> {
+    /// Narrow the neighbour set to nodes matching `expr`. The filter sticks to
+    /// the returned path — every subsequent traversal (further hops, edges,
+    /// properties) continues to see the filtered scope.
+    ///
+    /// Useful when you want one scoping rule to apply across the whole query.
+    /// E.g. restricting the whole traversal to a specific week:
+    ///
+    /// ```text
+    /// node(name: "A") { neighbours { filter(expr: {window: {...week...}}) {
+    ///   list { neighbours { list { name } } }   # further hops still windowed
+    /// } } }
+    /// ```
+    ///
+    /// Contrast with `select`, which applies here and is not carried through.
+
+    async fn filter(
+        &self,
+        #[graphql(desc = "Composite node filter (by name, property, type, etc.).")]
+        expr: GqlNodeFilter,
+    ) -> Result<Self, GraphError> {
         let self_clone = self.clone();
         blocking_compute(move || {
             let filter: CompositeNodeFilter = expr.try_into()?;
@@ -287,8 +394,27 @@ impl GqlPathFromNode {
         .await
     }
 
-    /// Returns filtered list of neighbour nodes
-    async fn select(&self, expr: GqlNodeFilter) -> Result<Self, GraphError> {
+    /// Narrow the neighbour set to nodes matching `expr`, but only at this hop
+    /// — further traversals out of these nodes see the unfiltered graph again.
+    ///
+    /// Useful when each hop needs a different scope. E.g. neighbours active on
+    /// Monday, then *their* neighbours active on Tuesday:
+    ///
+    /// ```text
+    /// node(name: "A") { neighbours { select(expr: {window: {...monday...}}) {
+    ///   list { neighbours { select(expr: {window: {...tuesday...}}) {
+    ///     list { name }
+    ///   } } }
+    /// } } }
+    /// ```
+    ///
+    /// Contrast with `filter`, which persists the scope through subsequent ops.
+
+    async fn select(
+        &self,
+        #[graphql(desc = "Composite node filter (by name, property, type, etc.).")]
+        expr: GqlNodeFilter,
+    ) -> Result<Self, GraphError> {
         let self_clone = self.clone();
         blocking_compute(move || {
             let filter: CompositeNodeFilter = expr.try_into()?;
diff --git a/raphtory-graphql/src/model/graph/property.rs b/raphtory-graphql/src/model/graph/property.rs
index 22ffb1b264..1153cc2876 100644
--- a/raphtory-graphql/src/model/graph/property.rs
+++ b/raphtory-graphql/src/model/graph/property.rs
@@ -6,6 +6,7 @@ use crate::{
     rayon::blocking_compute,
 };
 use async_graphql::{Error, Name, Value as GqlValue};
+use bigdecimal::BigDecimal;
 use dynamic_graphql::{
     InputObject, OneOfInput, ResolvedObject, ResolvedObjectFields, Scalar, ScalarValue,
 };
@@ -20,20 +21,25 @@ use raphtory::{
 };
 use raphtory_api::core::{
     entities::properties::prop::{IntoPropMap, Prop},
-    storage::{arc_str::ArcStr, timeindex::EventTime},
-    utils::time::IntoTime,
+    storage::{
+        arc_str::ArcStr,
+        timeindex::{AsTime, EventTime},
+    },
+    utils::time::{IntoTime, TryIntoTime},
 };
 use rustc_hash::FxHashMap;
+use serde::{Deserialize, Serialize};
 use serde_json::Number;
 use std::{
     collections::HashMap,
     convert::TryFrom,
     fmt,
     fmt::{Display, Formatter},
+    str::FromStr,
     sync::Arc,
 };
 
-#[derive(InputObject, Clone, Debug)]
+#[derive(InputObject, Clone, Debug, Serialize, Deserialize)]
 pub struct ObjectEntry {
     /// Key.
     pub key: String,
@@ -41,7 +47,8 @@ pub struct ObjectEntry {
     pub value: Value,
 }
 
-#[derive(OneOfInput, Clone, Debug)]
+#[derive(OneOfInput, Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
 pub enum Value {
     /// 8 bit unsigned integer.
     U8(u8),
@@ -67,6 +74,12 @@ pub enum Value {
     List(Vec<Value>),
     /// Object.
     Object(Vec<ObjectEntry>),
+    /// Timezone-aware datetime.
+    DTime(String),
+    /// Naive datetime (no timezone).
+    NDTime(String),
+    /// BigDecimal number (string representation, e.g. "3.14159" or "123e-5").
+    Decimal(String),
 }
 
 impl Display for Value {
@@ -93,6 +106,9 @@ impl Display for Value {
                     .join(", ");
                 write!(f, "Object({{{}}})", inner)
             }
+            Value::DTime(v) => write!(f, "DTime({})", v),
+            Value::NDTime(v) => write!(f, "NDTime({})", v),
+            Value::Decimal(v) => write!(f, "Decimal({})", v),
         }
     }
 }
@@ -131,6 +147,24 @@ fn value_to_prop(value: Value) -> Result<Prop, GraphError> {
                 .collect::<Result<FxHashMap<_, _>, _>>()?;
             Ok(Prop::Map(Arc::new(prop_map)))
         }
+        Value::DTime(s) => {
+            let t = s.try_into_time().map_err(GraphError::from)?;
+            t.dt().map(|dt| Prop::DTime(dt)).map_err(GraphError::from)
+        }
+        Value::NDTime(s) => {
+            let t = s.try_into_time().map_err(GraphError::from)?;
+            t.dt()
+                .map(|dt| Prop::NDTime(dt.naive_utc()))
+                .map_err(GraphError::from)
+        }
+        Value::Decimal(s) => {
+            let bd = BigDecimal::from_str(&s).map_err(|e| GraphError::InvalidProperty {
+                reason: format!("Invalid Decimal: {e}"),
+            })?;
+            Prop::try_from_bd(bd).map_err(|e| GraphError::InvalidProperty {
+                reason: format!("Decimal too large: {e}"),
+            })
+        }
     }
 }
 
@@ -192,7 +226,7 @@ fn prop_to_gql(prop: &Prop) -> GqlValue {
             .map(|number| GqlValue::Number(number))
             .unwrap_or(GqlValue::Null),
         Prop::Bool(b) => GqlValue::Boolean(*b),
-        Prop::List(l) => GqlValue::List(l.iter().map(|pp| prop_to_gql(pp)).collect()),
+        Prop::List(l) => GqlValue::List(l.iter().map(|pp| prop_to_gql(&pp)).collect()),
         Prop::Map(m) => GqlValue::Object(
             m.iter()
                 .map(|(k, v)| (Name::new(k.to_string()), prop_to_gql(v)))
@@ -200,11 +234,13 @@ fn prop_to_gql(prop: &Prop) -> GqlValue {
         ),
         Prop::DTime(t) => GqlValue::Number(t.timestamp_millis().into()),
         Prop::NDTime(t) => GqlValue::Number(t.and_utc().timestamp_millis().into()),
-        Prop::Array(a) => GqlValue::List(a.iter_prop().map(|p| prop_to_gql(&p)).collect()),
         Prop::Decimal(d) => GqlValue::String(d.to_string()),
     }
 }
 
+/// A single `(key, value)` property reading at a point in the graph view.
+/// The value is exposed both as a typed scalar (`value`) and as a
+/// human-readable string (`asString`).
 #[derive(Clone, ResolvedObject)]
 #[graphql(name = "Property")]
 pub(crate) struct GqlProperty {
@@ -226,19 +262,28 @@ impl From<(String, Prop)> for GqlProperty {
 
 #[ResolvedObjectFields]
 impl GqlProperty {
+    /// The property key (name).
     async fn key(&self) -> String {
         self.key.clone()
     }
 
+    /// The property value rendered as a human-readable string (e.g. `"10"`, `"hello"`,
+    /// `"2024-01-01T00:00:00Z"`). For programmatic access use `value`, which returns
+    /// a typed scalar.
     async fn as_string(&self) -> String {
         self.prop.to_string()
     }
 
+    /// The property value as a typed `PropertyOutput` scalar — numbers come back as
+    /// numbers, booleans as booleans, strings as strings, etc.
     async fn value(&self) -> GqlPropertyOutputVal {
         GqlPropertyOutputVal(self.prop.clone())
     }
 }
 
+/// A `(time, value)` pair — the output type of temporal-property accessors
+/// that need to report *when* a value was observed (e.g. `min`, `max`,
+/// `median`, `orderedDedupe`).
 #[derive(ResolvedObject, Clone)]
 #[graphql(name = "PropertyTuple")]
 pub(crate) struct GqlPropertyTuple {
@@ -260,20 +305,29 @@ impl From<(EventTime, Prop)> for GqlPropertyTuple {
 
 #[ResolvedObjectFields]
 impl GqlPropertyTuple {
+    /// The timestamp at which this value was recorded.
     async fn time(&self) -> GqlEventTime {
         self.time.into()
     }
 
+    /// The value rendered as a human-readable string. For programmatic access use
+    /// `value`, which returns a typed scalar.
     async fn as_string(&self) -> String {
         let self_clone = self.clone();
         blocking_compute(move || self_clone.prop.to_string()).await
     }
 
+    /// The value as a typed `PropertyOutput` scalar — numbers come back as numbers,
+    /// booleans as booleans, etc.
     async fn value(&self) -> GqlPropertyOutputVal {
         GqlPropertyOutputVal(self.prop.clone())
     }
 }
 
+/// The full timeline of a single property key on one entity. Exposes every
+/// update (via `values` / `history` / `orderedDedupe`), point lookups (`at`,
+/// `latest`), and aggregates over the timeline (`sum`, `mean`, `min`, `max`,
+/// `median`, `count`).
 #[derive(ResolvedObject, Clone)]
 #[graphql(name = "TemporalProperty")]
 pub(crate) struct GqlTemporalProperty {
@@ -295,46 +349,71 @@ impl From<(String, TemporalPropertyView<DynProps>)> for GqlTemporalProperty {
 
 #[ResolvedObjectFields]
 impl GqlTemporalProperty {
-    /// Key of a property.
+    /// The property key (name).
     async fn key(&self) -> String {
         self.key.clone()
     }
 
+    /// Event history for this property — one entry per temporal update, in
+    /// insertion order. Use this to navigate the full timeline: access the
+    /// raw `timestamps` / `datetimes` / `eventId` lists, analyse gaps between
+    /// updates via `intervals` (mean/median/min/max), ask `isEmpty`, or
+    /// paginate the events.
     async fn history(&self) -> GqlHistory {
         let self_clone = self.clone();
         blocking_compute(move || self_clone.prop.history().into()).await
     }
 
-    /// Return the values of the properties.
-    async fn values(&self) -> Vec<String> {
+    /// All values this property has ever taken, in temporal order (one per update).
+    /// Typed as `PropertyOutput` so numeric values stay numeric.
+    async fn values(&self) -> Vec<GqlPropertyOutputVal> {
         let self_clone = self.clone();
-        blocking_compute(move || self_clone.prop.values().map(|x| x.to_string()).collect()).await
+        blocking_compute(move || self_clone.prop.values().map(GqlPropertyOutputVal).collect()).await
     }
 
-    async fn at(&self, t: GqlTimeInput) -> Option<String> {
+    /// The value at or before time `t` (latest update on or before `t`). Returns null
+    /// if no update exists on or before `t`.
+
+    async fn at(
+        &self,
+        #[graphql(
+            desc = "A TimeInput (epoch millis integer, RFC3339 string, or `{timestamp, eventId}` object)."
+        )]
+        t: GqlTimeInput,
+    ) -> Option<GqlPropertyOutputVal> {
         let self_clone = self.clone();
-        blocking_compute(move || self_clone.prop.at(t.into_time()).map(|x| x.to_string())).await
+        blocking_compute(move || self_clone.prop.at(t.into_time()).map(GqlPropertyOutputVal)).await
     }
 
-    async fn latest(&self) -> Option<String> {
+    /// The most recent value, or null if the property has never been set in this view.
+    async fn latest(&self) -> Option<GqlPropertyOutputVal> {
         let self_clone = self.clone();
-        blocking_compute(move || self_clone.prop.latest().map(|x| x.to_string())).await
+        blocking_compute(move || self_clone.prop.latest().map(GqlPropertyOutputVal)).await
     }
 
-    async fn unique(&self) -> Vec<String> {
+    /// The set of distinct values this property has ever taken (order not guaranteed).
+    async fn unique(&self) -> Vec<GqlPropertyOutputVal> {
         let self_clone = self.clone();
         blocking_compute(move || {
             self_clone
                 .prop
                 .unique()
                 .into_iter()
-                .map(|x| x.to_string())
+                .map(GqlPropertyOutputVal)
                 .collect_vec()
         })
         .await
     }
 
-    async fn ordered_dedupe(&self, latest_time: bool) -> Vec<GqlPropertyTuple> {
+    /// Collapses runs of consecutive-equal updates into a single `(time, value)` pair.
+
+    async fn ordered_dedupe(
+        &self,
+        #[graphql(
+            desc = "If true, each run is represented by its *last* timestamp; if false, by its *first*. Useful for compressing chatter in a timeline."
+        )]
+        latest_time: bool,
+    ) -> Vec<GqlPropertyTuple> {
         let self_clone = self.clone();
         blocking_compute(move || {
             self_clone
@@ -346,8 +425,57 @@ impl GqlTemporalProperty {
         })
         .await
     }
+
+    /// Sum of all updates. Returns null if the dtype is not additive or the property is empty.
+    async fn sum(&self) -> Option<GqlPropertyOutputVal> {
+        let self_clone = self.clone();
+        blocking_compute(move || self_clone.prop.sum().map(GqlPropertyOutputVal)).await
+    }
+
+    /// Mean of all updates as an F64. Returns null if any value is non-numeric or the property is
+    /// empty.
+    async fn mean(&self) -> Option<GqlPropertyOutputVal> {
+        let self_clone = self.clone();
+        blocking_compute(move || self_clone.prop.mean().map(GqlPropertyOutputVal)).await
+    }
+
+    /// Alias for `mean` — same F64 average, same null cases.
+    async fn average(&self) -> Option<GqlPropertyOutputVal> {
+        let self_clone = self.clone();
+        blocking_compute(move || self_clone.prop.average().map(GqlPropertyOutputVal)).await
+    }
+
+    /// Minimum `(time, value)` pair. Returns null if the dtype is not comparable or the property is
+    /// empty.
+    async fn min(&self) -> Option<GqlPropertyTuple> {
+        let self_clone = self.clone();
+        blocking_compute(move || self_clone.prop.min().map(GqlPropertyTuple::from)).await
+    }
+
+    /// Maximum `(time, value)` pair. Returns null if the dtype is not comparable or the property is
+    /// empty.
+    async fn max(&self) -> Option<GqlPropertyTuple> {
+        let self_clone = self.clone();
+        blocking_compute(move || self_clone.prop.max().map(GqlPropertyTuple::from)).await
+    }
+
+    /// Median `(time, value)` pair (lower median on even-length inputs). Returns null if the dtype
+    /// is not comparable or the property is empty.
+    async fn median(&self) -> Option<GqlPropertyTuple> {
+        let self_clone = self.clone();
+        blocking_compute(move || self_clone.prop.median().map(GqlPropertyTuple::from)).await
+    }
+
+    /// Number of updates recorded for this property in the current view.
+    async fn count(&self) -> usize {
+        let self_clone = self.clone();
+        blocking_compute(move || self_clone.prop.count()).await
+    }
 }
 
+/// All temporal properties of an entity (metadata is exposed separately).
+/// Look up individual properties via `get` / `contains`, enumerate via
+/// `keys` / `values`, or drop into `temporal` for time-aware accessors.
 #[derive(ResolvedObject, Clone)]
 #[graphql(name = "Properties")]
 pub(crate) struct GqlProperties {
@@ -369,6 +497,9 @@ impl<P: Into<DynProperties>> From<P> for GqlProperties {
     }
 }
 
+/// The temporal-only view of an entity's properties. Each entry is a
+/// `TemporalProperty` carrying the full timeline for that key — use this when
+/// you need per-update iteration, time-indexed lookups, or aggregates.
 #[derive(ResolvedObject, Clone)]
 #[graphql(name = "TemporalProperties")]
 pub(crate) struct GqlTemporalProperties {
@@ -387,6 +518,10 @@ impl From<DynTemporalProperties> for GqlTemporalProperties {
     }
 }
 
+/// Constant key/value metadata attached to an entity (node, edge, or graph).
+/// Metadata has no timeline — each key maps to exactly one value for the
+/// lifetime of the entity. Separate from `Properties`, which carries
+/// time-varying data.
 #[derive(ResolvedObject, Clone)]
 #[graphql(name = "Metadata")]
 pub(crate) struct GqlMetadata {
@@ -407,19 +542,29 @@ impl<P: Into<DynMetadata>> From<P> for GqlMetadata {
 
 #[ResolvedObjectFields]
 impl GqlProperties {
-    /// Get property value matching the specified key.
-    async fn get(&self, key: String) -> Option<GqlProperty> {
+    /// Look up a single property by key. Returns null if no property with that key
+    /// exists in the current view.
+
+    async fn get(
+        &self,
+        #[graphql(desc = "The property name.")] key: String,
+    ) -> Option<GqlProperty> {
         self.props
             .get(key.as_str())
             .map(|p| (key.to_string(), p).into())
     }
 
-    /// Check if the key is in the properties.
-    async fn contains(&self, key: String) -> bool {
+    /// Returns true if a property with the given key exists in this view.
+
+    async fn contains(
+        &self,
+        #[graphql(desc = "The property name to look up.")] key: String,
+    ) -> bool {
         self.props.get(&key).is_some()
     }
 
-    /// Return all property keys.
+    /// All property keys present in the current view. Does not include metadata
+    /// — metadata is exposed separately via the entity's `metadata` field.
     async fn keys(&self) -> Vec<String> {
         let self_clone = self.clone();
         blocking_compute(move || {
@@ -432,8 +577,15 @@ impl GqlProperties {
         .await
     }
 
-    /// Return all property values.
-    async fn values(&self, keys: Option<Vec<String>>) -> Vec<GqlProperty> {
+    /// Snapshot of property values, one `{key, value}` entry per property.
+
+    async fn values(
+        &self,
+        #[graphql(
+            desc = "Optional whitelist. If provided, only properties with these keys are returned; if omitted or null, every property in the view is returned."
+        )]
+        keys: Option<Vec<String>>,
+    ) -> Vec<GqlProperty> {
         let self_clone = self.clone();
         blocking_compute(move || match keys {
             Some(keys) => self_clone
@@ -457,6 +609,8 @@ impl GqlProperties {
         .await
     }
 
+    /// The temporal-only view of these properties — excludes metadata (which has no
+    /// history) and lets you drill into per-key timelines and aggregates.
     async fn temporal(&self) -> GqlTemporalProperties {
         self.props.temporal().into()
     }
@@ -464,26 +618,42 @@ impl GqlProperties {
 
 #[ResolvedObjectFields]
 impl GqlMetadata {
-    /// Get metadata value matching the specified key.
-    async fn get(&self, key: String) -> Option<GqlProperty> {
+    /// Look up a single metadata value by key. Returns null if no metadata with that
+    /// key exists.
+
+    async fn get(
+        &self,
+        #[graphql(desc = "The metadata name.")] key: String,
+    ) -> Option<GqlProperty> {
         self.props
             .get(key.as_str())
             .map(|p| (key.to_string(), p).into())
     }
 
-    /// /// Check if the key is in the metadata.
-    async fn contains(&self, key: String) -> bool {
+    /// Returns true if a metadata entry with the given key exists.
+
+    async fn contains(
+        &self,
+        #[graphql(desc = "The metadata name to look up.")] key: String,
+    ) -> bool {
         self.props.contains(key.as_str())
     }
 
-    /// Return all metadata keys.
+    /// All metadata keys present on this entity.
     async fn keys(&self) -> Vec<String> {
         let self_clone = self.clone();
         blocking_compute(move || self_clone.props.keys().map(|k| k.clone().into()).collect()).await
     }
 
-    /// /// Return all metadata values.
-    pub(crate) async fn values(&self, keys: Option<Vec<String>>) -> Vec<GqlProperty> {
+    /// All metadata values as `{key, value}` entries.
+
+    pub(crate) async fn values(
+        &self,
+        #[graphql(
+            desc = "Optional whitelist. If provided, only metadata with these keys is returned; if omitted, every metadata entry is returned."
+        )]
+        keys: Option<Vec<String>>,
+    ) -> Vec<GqlProperty> {
         let self_clone = self.clone();
         blocking_compute(move || match keys {
             Some(keys) => self_clone
@@ -510,17 +680,26 @@ impl GqlMetadata {
 
 #[ResolvedObjectFields]
 impl GqlTemporalProperties {
-    /// Get property value matching the specified key.
-    async fn get(&self, key: String) -> Option<GqlTemporalProperty> {
+    /// Look up a single temporal property by key. Returns null if there's no temporal
+    /// property with that key.
+
+    async fn get(
+        &self,
+        #[graphql(desc = "The property name.")] key: String,
+    ) -> Option<GqlTemporalProperty> {
         self.props.get(key.as_str()).map(move |p| (key, p).into())
     }
 
-    /// Check if the key is in the properties.
-    async fn contains(&self, key: String) -> bool {
+    /// Returns true if a temporal property with the given key exists.
+
+    async fn contains(
+        &self,
+        #[graphql(desc = "The property name to look up.")] key: String,
+    ) -> bool {
         self.props.get(&key).is_some()
     }
 
-    /// Return all property keys.
+    /// All temporal-property keys present in this view.
     async fn keys(&self) -> Vec<String> {
         let self_clone = self.clone();
         blocking_compute(move || {
@@ -533,8 +712,16 @@ impl GqlTemporalProperties {
         .await
     }
 
-    /// Return all property values.
-    async fn values(&self, keys: Option<Vec<String>>) -> Vec<GqlTemporalProperty> {
+    /// All temporal properties, each as a `TemporalProperty` with its full timeline
+    /// available. Use `history`, `values`, `latest`, `at`, etc. on each entry.
+
+    async fn values(
+        &self,
+        #[graphql(
+            desc = "Optional whitelist. If provided, only temporal properties with these keys are returned; if omitted, every temporal property in the view is returned."
+        )]
+        keys: Option<Vec<String>>,
+    ) -> Vec<GqlTemporalProperty> {
         let self_clone = self.clone();
         blocking_compute(move || match keys {
             Some(keys) => self_clone
diff --git a/raphtory-graphql/src/model/graph/timeindex.rs b/raphtory-graphql/src/model/graph/timeindex.rs
index 42cc7e713a..fd01768ca9 100644
--- a/raphtory-graphql/src/model/graph/timeindex.rs
+++ b/raphtory-graphql/src/model/graph/timeindex.rs
@@ -3,16 +3,22 @@ use chrono::format::{Item, StrftimeItems};
 use dynamic_graphql::{ResolvedObject, ResolvedObjectFields, Scalar, ScalarValue};
 use raphtory_api::core::{
     storage::timeindex::{AsTime, EventTime},
-    utils::time::{IntoTime, TryIntoTime},
+    utils::time::{InputTime, IntoTime, TryIntoTime},
 };
+use serde::{Deserialize, Serialize};
 
 /// Input for primary time component. Expects Int, DateTime formatted String, or Object { timestamp, eventId }
 /// where the timestamp is either an Int or a DateTime formatted String, and eventId is a non-negative Int.
 /// Valid string formats are RFC3339, RFC2822, %Y-%m-%d, %Y-%m-%dT%H:%M:%S%.3f, %Y-%m-%dT%H:%M:%S%,
 /// %Y-%m-%d %H:%M:%S%.3f and %Y-%m-%d %H:%M:%S%.
-#[derive(Scalar, Clone, Debug)]
+///
+/// Internally wraps `InputTime` so write paths (`addNode`, `addEdge`,
+/// `addProperties`, etc.) can preserve auto-increment of `event_id` when only
+/// a timestamp is given. Pass the object form `{timestamp, eventId}` to lock
+/// the event_id explicitly.
+#[derive(Scalar, Clone, Debug, Serialize, Deserialize)]
 #[graphql(name = "TimeInput")]
-pub struct GqlTimeInput(pub EventTime);
+pub struct GqlTimeInput(pub InputTime);
 
 impl ScalarValue for GqlTimeInput {
     fn from_value(value: GqlValue) -> Result<Self, Error> {
@@ -22,11 +28,11 @@ impl ScalarValue for GqlTimeInput {
                 .ok_or(Error::new(
                     "Expected Int, DateTime formatted String, or Object { timestamp, eventId }.",
                 ))
-                .map(|timestamp| GqlTimeInput(EventTime::start(timestamp))),
+                .map(|timestamp| GqlTimeInput(InputTime::Simple(timestamp))),
 
             GqlValue::String(dt) => dt
                 .try_into_time()
-                .map(|t| GqlTimeInput(t.set_event_id(0)))
+                .map(|t| GqlTimeInput(InputTime::Simple(t.t())))
                 .map_err(|e| Error::new(e.to_string())),
 
             // TimeInput: Object { timestamp: Number | String, eventId: Number }
@@ -61,7 +67,7 @@ impl ScalarValue for GqlTimeInput {
                     _ => return Err(Error::new("eventId must be a non-negative Int.")),
                 };
 
-                Ok(GqlTimeInput(EventTime::new(ts, idx)))
+                Ok(GqlTimeInput(InputTime::Indexed(ts, idx)))
             }
             _ => Err(Error::new(
                 "Expected Int, DateTime formatted String, or Object { timestamp, eventId }.",
@@ -70,28 +76,48 @@ impl ScalarValue for GqlTimeInput {
     }
 
     fn to_value(&self) -> GqlValue {
-        self.0.t().into()
+        self.t().into()
     }
 }
 
 impl From<i64> for GqlTimeInput {
     fn from(value: i64) -> Self {
-        GqlTimeInput(EventTime::start(value))
+        GqlTimeInput(InputTime::Simple(value))
+    }
+}
+
+impl GqlTimeInput {
+    /// Extract just the timestamp (for read-side query args like `window`,
+    /// `at`, `before`, `after`). Auto-increment semantics aren't relevant
+    /// when only reading.
+    pub fn t(&self) -> i64 {
+        match &self.0 {
+            InputTime::Simple(t) => *t,
+            InputTime::Indexed(t, _) => *t,
+        }
+    }
+
+    /// Pass the underlying `InputTime` straight through to write paths so
+    /// `Simple` causes the graph to allocate a fresh `event_id` and
+    /// `Indexed` locks one explicitly.
+    pub fn into_input_time(self) -> InputTime {
+        self.0
     }
 }
 
 impl IntoTime for GqlTimeInput {
+    /// Build an `EventTime`. For read-side use only — write paths should call
+    /// `into_input_time` instead so auto-increment of `event_id` works.
     fn into_time(self) -> EventTime {
-        self.0
+        match self.0 {
+            InputTime::Simple(t) => EventTime::start(t),
+            InputTime::Indexed(t, e) => EventTime::new(t, e),
+        }
     }
 }
 
 pub fn dt_format_str_is_valid(fmt_str: &str) -> bool {
-    if StrftimeItems::new(fmt_str).any(|it| matches!(it, Item::Error)) {
-        false
-    } else {
-        true
-    }
+    !StrftimeItems::new(fmt_str).any(|it| matches!(it, Item::Error))
 }
 
 /// Raphtory’s EventTime.
@@ -127,7 +153,14 @@ impl GqlEventTime {
     /// Defaults to RFC 3339 if not provided (e.g., "2023-12-25T10:30:45.123Z").
     /// Refer to chrono::format::strftime for formatting specifiers and escape sequences.
     /// Raises an error if a time conversion fails.
-    async fn datetime(&self, format_string: Option<String>) -> Result<Option<String>, Error> {
+
+    async fn datetime(
+        &self,
+        #[graphql(
+            desc = "Optional format string for the rendered datetime. Uses `%`-style specifiers — for example `%Y-%m-%d` for `2024-01-15`, `%Y-%m-%d %H:%M:%S` for `2024-01-15 10:30:00`, or `%H:%M` for `10:30`. Defaults to RFC 3339 (e.g. `2024-01-15T10:30:45.123+00:00`) when omitted."
+        )]
+        format_string: Option<String>,
+    ) -> Result<Option<String>, Error> {
         let fmt_string = format_string.as_deref().unwrap_or("%+"); // %+ is RFC 3339
         if dt_format_str_is_valid(fmt_string) {
             self.inner
diff --git a/raphtory-graphql/src/model/graph/vector_selection.rs b/raphtory-graphql/src/model/graph/vector_selection.rs
index 9560d43cff..58e136a75b 100644
--- a/raphtory-graphql/src/model/graph/vector_selection.rs
+++ b/raphtory-graphql/src/model/graph/vector_selection.rs
@@ -2,6 +2,7 @@ use super::{
     document::GqlDocument,
     edge::GqlEdge,
     node::GqlNode,
+    node_id::GqlNodeId,
     vectorised_graph::{IntoWindowTuple, VectorisedGraphWindow},
 };
 use crate::rayon::blocking_compute;
@@ -14,12 +15,16 @@ use raphtory::{
 
 #[derive(InputObject)]
 pub(super) struct InputEdge {
-    /// Source node.
-    src: String,
-    /// Destination node.
-    dst: String,
+    /// Source node id (string or non-negative integer).
+    src: GqlNodeId,
+    /// Destination node id (string or non-negative integer).
+    dst: GqlNodeId,
 }
 
+/// A working set of documents / nodes / edges built up via similarity
+/// searches on a `VectorisedGraph`. Selections are mutable: you can grow
+/// them with more hops (`expand*`), dereference the contents (`nodes`,
+/// `edges`, `getDocuments`), or start fresh with `emptySelection`.
 #[derive(ResolvedObject)]
 #[graphql(name = "VectorSelection")]
 pub(crate) struct GqlVectorSelection(VectorSelection<MaterializedGraph>);
@@ -56,29 +61,45 @@ impl GqlVectorSelection {
             .collect())
     }
 
-    /// Adds all the documents associated with the specified nodes to the current selection.
-    ///
-    /// Documents added by this call are assumed to have a score of 0.
-    async fn add_nodes(&self, nodes: Vec<String>) -> Self {
+    /// Add every document associated with the named nodes to the selection.
+    /// Documents added this way receive a score of 0 (no similarity ranking).
+
+    async fn add_nodes(
+        &self,
+        #[graphql(desc = "Node ids whose documents to include.")] nodes: Vec<GqlNodeId>,
+    ) -> Self {
         let mut selection = self.cloned();
         selection.add_nodes(nodes);
         selection.into()
     }
 
-    /// Adds all the documents associated with the specified edges to the current selection.
-    ///
-    /// Documents added by this call are assumed to have a score of 0.
-    async fn add_edges(&self, edges: Vec<InputEdge>) -> Self {
+    /// Add every document associated with the named edges to the selection.
+    /// Documents added this way receive a score of 0 (no similarity ranking).
+
+    async fn add_edges(
+        &self,
+        #[graphql(desc = "List of `{src, dst}` pairs identifying the edges.")] edges: Vec<
+            InputEdge,
+        >,
+    ) -> Self {
         let mut selection = self.cloned();
         let edges = edges.into_iter().map(|edge| (edge.src, edge.dst)).collect();
         selection.add_edges(edges);
         selection.into()
     }
 
-    /// Add all the documents a specified number of hops away to the selection.
-    ///
-    /// Two documents A and B are considered to be 1 hop away of each other if they are on the same entity or if they are on the same node and edge pair.
-    async fn expand(&self, hops: usize, window: Option<VectorisedGraphWindow>) -> Self {
+    /// Grow the selection by including documents that are within `hops` of any
+    /// document already in the selection. Two documents are 1 hop apart if
+    /// they're on the same entity or on a connected node/edge pair.
+
+    async fn expand(
+        &self,
+        #[graphql(desc = "Number of expansion rounds (1 = direct neighbours).")] hops: usize,
+        #[graphql(
+            desc = "Optional `{start, end}` to restrict expansion to entities active in that interval."
+        )]
+        window: Option<VectorisedGraphWindow>,
+    ) -> Self {
         let window = window.into_window_tuple();
         let mut selection = self.cloned();
         blocking_compute(move || {
@@ -88,11 +109,18 @@ impl GqlVectorSelection {
         .await
     }
 
-    /// Adds documents, from the set of one hop neighbours to the current selection, to the selection based on their similarity score with the specified query. This function loops so that the set of one hop neighbours expands on each loop and number of documents added is determined by the specified limit.
+    /// Iteratively expand the selection by similarity to a natural-language
+    /// query. Each pass takes the one-hop neighbour set of the current
+    /// selection and adds the highest-scoring entities (mixed nodes and
+    /// edges); the loop continues until `limit` entities have been added.
+
     async fn expand_entities_by_similarity(
         &self,
-        query: String,
-        limit: usize,
+        #[graphql(desc = "Natural-language search string; embedded by the server.")] query: String,
+        #[graphql(desc = "Total number of entities to add across all passes.")] limit: usize,
+        #[graphql(
+            desc = "Optional `{start, end}` to restrict matches to entities active in that interval."
+        )]
         window: Option<VectorisedGraphWindow>,
     ) -> GraphResult<Self> {
         let vector = self.embed_text(query).await?;
@@ -104,11 +132,16 @@ impl GqlVectorSelection {
         Ok(selection.into())
     }
 
-    /// Add the adjacent nodes with higher score for query to the selection up to a specified limit. This function loops like expand_entities_by_similarity but is restricted to nodes.
+    /// Like `expandEntitiesBySimilarity` but restricted to nodes — iteratively
+    /// add the highest-scoring adjacent nodes to the selection.
+
     async fn expand_nodes_by_similarity(
         &self,
-        query: String,
-        limit: usize,
+        #[graphql(desc = "Natural-language search string; embedded by the server.")] query: String,
+        #[graphql(desc = "Total number of nodes to add across all passes.")] limit: usize,
+        #[graphql(
+            desc = "Optional `{start, end}` to restrict matches to nodes active in that interval."
+        )]
         window: Option<VectorisedGraphWindow>,
     ) -> GraphResult<Self> {
         let vector = self.embed_text(query).await?;
@@ -120,11 +153,16 @@ impl GqlVectorSelection {
         Ok(selection.into())
     }
 
-    /// Add the adjacent edges with higher score for query to the selection up to a specified limit. This function loops like expand_entities_by_similarity but is restricted to edges.
+    /// Like `expandEntitiesBySimilarity` but restricted to edges — iteratively
+    /// add the highest-scoring adjacent edges to the selection.
+
     async fn expand_edges_by_similarity(
         &self,
-        query: String,
-        limit: usize,
+        #[graphql(desc = "Natural-language search string; embedded by the server.")] query: String,
+        #[graphql(desc = "Total number of edges to add across all passes.")] limit: usize,
+        #[graphql(
+            desc = "Optional `{start, end}` to restrict matches to edges active in that interval."
+        )]
         window: Option<VectorisedGraphWindow>,
     ) -> GraphResult<Self> {
         let vector = self.embed_text(query).await?;
diff --git a/raphtory-graphql/src/model/graph/vectorised_graph.rs b/raphtory-graphql/src/model/graph/vectorised_graph.rs
index 23e4479588..eb455b13f9 100644
--- a/raphtory-graphql/src/model/graph/vectorised_graph.rs
+++ b/raphtory-graphql/src/model/graph/vectorised_graph.rs
@@ -1,4 +1,4 @@
-use crate::rayon::blocking_compute;
+use crate::{model::graph::timeindex::GqlTimeInput, rayon::blocking_compute};
 
 use super::vector_selection::GqlVectorSelection;
 use dynamic_graphql::{InputObject, ResolvedObject, ResolvedObjectFields};
@@ -6,13 +6,14 @@ use raphtory::{
     db::api::view::MaterializedGraph, errors::GraphResult,
     vectors::vectorised_graph::VectorisedGraph,
 };
+use raphtory_api::core::{storage::timeindex::AsTime, utils::time::IntoTime};
 
 #[derive(InputObject)]
 pub(super) struct VectorisedGraphWindow {
-    /// Start time.
-    start: i64,
-    /// End time.
-    end: i64,
+    /// Inclusive lower bound of the search window.
+    start: GqlTimeInput,
+    /// Exclusive upper bound of the search window.
+    end: GqlTimeInput,
 }
 
 pub(super) trait IntoWindowTuple {
@@ -21,10 +22,14 @@ pub(super) trait IntoWindowTuple {
 
 impl IntoWindowTuple for Option<VectorisedGraphWindow> {
     fn into_window_tuple(self) -> Option<(i64, i64)> {
-        self.map(|window| (window.start, window.end))
+        self.map(|window| (window.start.into_time().t(), window.end.into_time().t()))
     }
 }
 
+/// A graph with embedded vector representations for its nodes and edges.
+/// Exposes similarity search over documents, nodes, and edges, plus
+/// selection building (`emptySelection`) and index maintenance
+/// (`optimizeIndex`).
 #[derive(ResolvedObject)]
 #[graphql(name = "VectorisedGraph")]
 pub(crate) struct GqlVectorisedGraph(VectorisedGraph<MaterializedGraph>);
@@ -37,7 +42,9 @@ impl From<VectorisedGraph<MaterializedGraph>> for GqlVectorisedGraph {
 
 #[ResolvedObjectFields]
 impl GqlVectorisedGraph {
-    /// Optmize the vector index
+    /// Rebuild (or incrementally update) the on-disk vector indexes for nodes
+    /// and edges so subsequent similarity searches hit the fresh embeddings.
+    /// Safe to call repeatedly; returns true on success.
     async fn optimize_index(&self) -> GraphResult<bool> {
         self.0.optimize_index().await?;
         Ok(true)
@@ -48,11 +55,17 @@ impl GqlVectorisedGraph {
         self.0.empty_selection().into()
     }
 
-    /// Search the top scoring entities according to a specified query returning no more than a specified limit of entities.
+    /// Find the highest-scoring nodes *and* edges (mixed) by similarity to a
+    /// natural-language query. The query is embedded server-side and matched
+    /// against indexed entity vectors.
+
     async fn entities_by_similarity(
         &self,
-        query: String,
-        limit: usize,
+        #[graphql(desc = "Natural-language search string; embedded by the server.")] query: String,
+        #[graphql(desc = "Maximum number of results to return.")] limit: usize,
+        #[graphql(
+            desc = "Optional `{start, end}` to restrict matches to entities active in that interval."
+        )]
         window: Option<VectorisedGraphWindow>,
     ) -> GraphResult<GqlVectorSelection> {
         let vector = self.0.embed_text(query).await?;
@@ -63,11 +76,17 @@ impl GqlVectorisedGraph {
         Ok(query.execute().await?.into())
     }
 
-    /// Search the top scoring nodes according to a specified query returning no more than a specified limit of nodes.
+    /// Find the highest-scoring nodes by similarity to a natural-language
+    /// query. The query is embedded server-side and matched against indexed
+    /// node vectors.
+
     async fn nodes_by_similarity(
         &self,
-        query: String,
-        limit: usize,
+        #[graphql(desc = "Natural-language search string; embedded by the server.")] query: String,
+        #[graphql(desc = "Maximum number of nodes to return.")] limit: usize,
+        #[graphql(
+            desc = "Optional `{start, end}` to restrict matches to nodes active in that interval."
+        )]
         window: Option<VectorisedGraphWindow>,
     ) -> GraphResult<GqlVectorSelection> {
         let vector = self.0.embed_text(query).await?;
@@ -77,11 +96,17 @@ impl GqlVectorisedGraph {
         Ok(query.execute().await?.into())
     }
 
-    /// Search the top scoring edges according to a specified query returning no more than a specified limit of edges.
+    /// Find the highest-scoring edges by similarity to a natural-language
+    /// query. The query is embedded server-side and matched against indexed
+    /// edge vectors.
+
     async fn edges_by_similarity(
         &self,
-        query: String,
-        limit: usize,
+        #[graphql(desc = "Natural-language search string; embedded by the server.")] query: String,
+        #[graphql(desc = "Maximum number of edges to return.")] limit: usize,
+        #[graphql(
+            desc = "Optional `{start, end}` to restrict matches to edges active in that interval."
+        )]
         window: Option<VectorisedGraphWindow>,
     ) -> GraphResult<GqlVectorSelection> {
         let vector = self.0.embed_text(query).await?;
diff --git a/raphtory-graphql/src/model/graph/windowset.rs b/raphtory-graphql/src/model/graph/windowset.rs
index 32b1501029..e118986553 100644
--- a/raphtory-graphql/src/model/graph/windowset.rs
+++ b/raphtory-graphql/src/model/graph/windowset.rs
@@ -1,11 +1,17 @@
 use crate::{
     model::graph::{
-        edge::GqlEdge, edges::GqlEdges, graph::GqlGraph, node::GqlNode, nodes::GqlNodes,
+        collection::{check_list_allowed, check_page_limit},
+        edge::GqlEdge,
+        edges::GqlEdges,
+        graph::GqlGraph,
+        node::GqlNode,
+        nodes::GqlNodes,
         path_from_node::GqlPathFromNode,
     },
     paths::ExistingGraphFolder,
     rayon::blocking_compute,
 };
+use async_graphql::Context;
 use dynamic_graphql::{ResolvedObject, ResolvedObjectFields};
 use raphtory::db::{
     api::{
@@ -15,6 +21,10 @@ use raphtory::db::{
     graph::{edge::EdgeView, edges::Edges, node::NodeView, nodes::Nodes, path::PathFromNode},
 };
 
+/// A lazy sequence of graph snapshots produced by `rolling` or `expanding`.
+/// Each entry is a `Graph` at a different window over time. Iterate via
+/// `list` / `page` (or count with `count`). Subsequent view ops apply
+/// per-window.
 #[derive(ResolvedObject, Clone)]
 #[graphql(name = "GraphWindowSet")]
 pub(crate) struct GqlGraphWindowSet {
@@ -29,7 +39,8 @@ impl GqlGraphWindowSet {
 }
 #[ResolvedObjectFields]
 impl GqlGraphWindowSet {
-    /// Returns the number of items.
+    /// Number of windows in this set. Materialising all windows is expensive for
+    /// large graphs — prefer `page` over `list` when iterating.
     async fn count(&self) -> usize {
         let self_clone = self.clone();
         blocking_compute(move || self_clone.ws.clone().count()).await
@@ -40,14 +51,21 @@ impl GqlGraphWindowSet {
     ///
     /// For example, if page(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
     /// will be returned.
+
     async fn page(
         &self,
-        limit: usize,
+        ctx: &Context<'_>,
+        #[graphql(desc = "Maximum number of items to return on this page.")] limit: usize,
+        #[graphql(desc = "Extra items to skip on top of `pageIndex` paging (default 0).")]
         offset: Option<usize>,
+        #[graphql(
+            desc = "Zero-based page number; multiplies `limit` to determine where to start (default 0)."
+        )]
         page_index: Option<usize>,
-    ) -> Vec<GqlGraph> {
+    ) -> async_graphql::Result<Vec<GqlGraph>> {
+        check_page_limit(ctx, limit)?;
         let self_clone = self.clone();
-        blocking_compute(move || {
+        Ok(blocking_compute(move || {
             let start = page_index.unwrap_or(0) * limit + offset.unwrap_or(0);
             self_clone
                 .ws
@@ -57,22 +75,28 @@ impl GqlGraphWindowSet {
                 .map(|g| GqlGraph::new(self_clone.path.clone(), g))
                 .collect()
         })
-        .await
+        .await)
     }
 
-    async fn list(&self) -> Vec<GqlGraph> {
+    /// Materialise every window as a list. Rejected by the server when bulk list
+    /// endpoints are disabled; use `page` for paginated access instead.
+    async fn list(&self, ctx: &Context<'_>) -> async_graphql::Result<Vec<GqlGraph>> {
+        check_list_allowed(ctx)?;
         let self_clone = self.clone();
-        blocking_compute(move || {
+        Ok(blocking_compute(move || {
             self_clone
                 .ws
                 .clone()
                 .map(|g| GqlGraph::new(self_clone.path.clone(), g))
                 .collect()
         })
-        .await
+        .await)
     }
 }
 
+/// A lazy sequence of per-window views of a single node, produced by
+/// `node.rolling` / `node.expanding`. Each entry is the node as it exists in
+/// that window.
 #[derive(ResolvedObject, Clone)]
 #[graphql(name = "NodeWindowSet")]
 pub(crate) struct GqlNodeWindowSet {
@@ -86,6 +110,8 @@ impl GqlNodeWindowSet {
 }
 #[ResolvedObjectFields]
 impl GqlNodeWindowSet {
+    /// Number of windows in this set. Materialising all windows is expensive for
+    /// large graphs — prefer `page` over `list` when iterating.
     async fn count(&self) -> usize {
         let self_clone = self.clone();
         blocking_compute(move || self_clone.ws.clone().count()).await
@@ -96,14 +122,21 @@ impl GqlNodeWindowSet {
     ///
     /// For example, if page(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
     /// will be returned.
+
     async fn page(
         &self,
-        limit: usize,
+        ctx: &Context<'_>,
+        #[graphql(desc = "Maximum number of items to return on this page.")] limit: usize,
+        #[graphql(desc = "Extra items to skip on top of `pageIndex` paging (default 0).")]
         offset: Option<usize>,
+        #[graphql(
+            desc = "Zero-based page number; multiplies `limit` to determine where to start (default 0)."
+        )]
         page_index: Option<usize>,
-    ) -> Vec<GqlNode> {
+    ) -> async_graphql::Result<Vec<GqlNode>> {
+        check_page_limit(ctx, limit)?;
         let self_clone = self.clone();
-        blocking_compute(move || {
+        Ok(blocking_compute(move || {
             let start = page_index.unwrap_or(0) * limit + offset.unwrap_or(0);
             self_clone
                 .ws
@@ -113,15 +146,21 @@ impl GqlNodeWindowSet {
                 .map(|n| n.into())
                 .collect()
         })
-        .await
+        .await)
     }
 
-    async fn list(&self) -> Vec<GqlNode> {
+    /// Materialise every window as a list. Rejected by the server when bulk list
+    /// endpoints are disabled; use `page` for paginated access instead.
+    async fn list(&self, ctx: &Context<'_>) -> async_graphql::Result<Vec<GqlNode>> {
+        check_list_allowed(ctx)?;
         let self_clone = self.clone();
-        blocking_compute(move || self_clone.ws.clone().map(|n| n.into()).collect()).await
+        Ok(blocking_compute(move || self_clone.ws.clone().map(|n| n.into()).collect()).await)
     }
 }
 
+/// A lazy sequence of per-window node collections, produced by
+/// `nodes.rolling` / `nodes.expanding`. Each entry is a `Nodes` collection
+/// as it exists in that window.
 #[derive(ResolvedObject, Clone)]
 #[graphql(name = "NodesWindowSet")]
 pub(crate) struct GqlNodesWindowSet {
@@ -137,6 +176,8 @@ impl GqlNodesWindowSet {
 }
 #[ResolvedObjectFields]
 impl GqlNodesWindowSet {
+    /// Number of windows in this set. Materialising all windows is expensive for
+    /// large graphs — prefer `page` over `list` when iterating.
     async fn count(&self) -> usize {
         let self_clone = self.clone();
         blocking_compute(move || self_clone.ws.clone().count()).await
@@ -147,14 +188,21 @@ impl GqlNodesWindowSet {
     ///
     /// For example, if page(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
     /// will be returned.
+
     async fn page(
         &self,
-        limit: usize,
+        ctx: &Context<'_>,
+        #[graphql(desc = "Maximum number of items to return on this page.")] limit: usize,
+        #[graphql(desc = "Extra items to skip on top of `pageIndex` paging (default 0).")]
         offset: Option<usize>,
+        #[graphql(
+            desc = "Zero-based page number; multiplies `limit` to determine where to start (default 0)."
+        )]
         page_index: Option<usize>,
-    ) -> Vec<GqlNodes> {
+    ) -> async_graphql::Result<Vec<GqlNodes>> {
+        check_page_limit(ctx, limit)?;
         let self_clone = self.clone();
-        blocking_compute(move || {
+        Ok(blocking_compute(move || {
             let start = page_index.unwrap_or(0) * limit + offset.unwrap_or(0);
             self_clone
                 .ws
@@ -164,15 +212,24 @@ impl GqlNodesWindowSet {
                 .map(|n| GqlNodes::new(n))
                 .collect()
         })
-        .await
+        .await)
     }
 
-    async fn list(&self) -> Vec<GqlNodes> {
+    /// Materialise every window as a list. Rejected by the server when bulk list
+    /// endpoints are disabled; use `page` for paginated access instead.
+    async fn list(&self, ctx: &Context<'_>) -> async_graphql::Result<Vec<GqlNodes>> {
+        check_list_allowed(ctx)?;
         let self_clone = self.clone();
-        blocking_compute(move || self_clone.ws.clone().map(|n| GqlNodes::new(n)).collect()).await
+        Ok(
+            blocking_compute(move || self_clone.ws.clone().map(|n| GqlNodes::new(n)).collect())
+                .await,
+        )
     }
 }
 
+/// A lazy sequence of per-window neighbour sets, produced by
+/// `neighbours.rolling` / `neighbours.expanding` (or the in/out variants).
+/// Each entry is a `PathFromNode` scoped to that window.
 #[derive(ResolvedObject, Clone)]
 #[graphql(name = "PathFromNodeWindowSet")]
 pub(crate) struct GqlPathFromNodeWindowSet {
@@ -186,6 +243,8 @@ impl GqlPathFromNodeWindowSet {
 }
 #[ResolvedObjectFields]
 impl GqlPathFromNodeWindowSet {
+    /// Number of windows in this set. Materialising all windows is expensive for
+    /// large graphs — prefer `page` over `list` when iterating.
     async fn count(&self) -> usize {
         let self_clone = self.clone();
         blocking_compute(move || self_clone.ws.clone().count()).await
@@ -196,14 +255,21 @@ impl GqlPathFromNodeWindowSet {
     ///
     /// For example, if page(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
     /// will be returned.
+
     async fn page(
         &self,
-        limit: usize,
+        ctx: &Context<'_>,
+        #[graphql(desc = "Maximum number of items to return on this page.")] limit: usize,
+        #[graphql(desc = "Extra items to skip on top of `pageIndex` paging (default 0).")]
         offset: Option<usize>,
+        #[graphql(
+            desc = "Zero-based page number; multiplies `limit` to determine where to start (default 0)."
+        )]
         page_index: Option<usize>,
-    ) -> Vec<GqlPathFromNode> {
+    ) -> async_graphql::Result<Vec<GqlPathFromNode>> {
+        check_page_limit(ctx, limit)?;
         let self_clone = self.clone();
-        blocking_compute(move || {
+        Ok(blocking_compute(move || {
             let start = page_index.unwrap_or(0) * limit + offset.unwrap_or(0);
             self_clone
                 .ws
@@ -213,22 +279,28 @@ impl GqlPathFromNodeWindowSet {
                 .map(|n| GqlPathFromNode::new(n))
                 .collect()
         })
-        .await
+        .await)
     }
 
-    async fn list(&self) -> Vec<GqlPathFromNode> {
+    /// Materialise every window as a list. Rejected by the server when bulk list
+    /// endpoints are disabled; use `page` for paginated access instead.
+    async fn list(&self, ctx: &Context<'_>) -> async_graphql::Result<Vec<GqlPathFromNode>> {
+        check_list_allowed(ctx)?;
         let self_clone = self.clone();
-        blocking_compute(move || {
+        Ok(blocking_compute(move || {
             self_clone
                 .ws
                 .clone()
                 .map(|n| GqlPathFromNode::new(n))
                 .collect()
         })
-        .await
+        .await)
     }
 }
 
+/// A lazy sequence of per-window views of a single edge, produced by
+/// `edge.rolling` / `edge.expanding`. Each entry is the edge as it exists in
+/// that window.
 #[derive(ResolvedObject, Clone)]
 #[graphql(name = "EdgeWindowSet")]
 pub(crate) struct GqlEdgeWindowSet {
@@ -242,6 +314,8 @@ impl GqlEdgeWindowSet {
 }
 #[ResolvedObjectFields]
 impl GqlEdgeWindowSet {
+    /// Number of windows in this set. Materialising all windows is expensive for
+    /// large graphs — prefer `page` over `list` when iterating.
     async fn count(&self) -> usize {
         let self_clone = self.clone();
         blocking_compute(move || self_clone.ws.clone().count()).await
@@ -252,14 +326,21 @@ impl GqlEdgeWindowSet {
     ///
     /// For example, if page(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
     /// will be returned.
+
     async fn page(
         &self,
-        limit: usize,
+        ctx: &Context<'_>,
+        #[graphql(desc = "Maximum number of items to return on this page.")] limit: usize,
+        #[graphql(desc = "Extra items to skip on top of `pageIndex` paging (default 0).")]
         offset: Option<usize>,
+        #[graphql(
+            desc = "Zero-based page number; multiplies `limit` to determine where to start (default 0)."
+        )]
         page_index: Option<usize>,
-    ) -> Vec<GqlEdge> {
+    ) -> async_graphql::Result<Vec<GqlEdge>> {
+        check_page_limit(ctx, limit)?;
         let self_clone = self.clone();
-        blocking_compute(move || {
+        Ok(blocking_compute(move || {
             let start = page_index.unwrap_or(0) * limit + offset.unwrap_or(0);
             self_clone
                 .ws
@@ -269,15 +350,21 @@ impl GqlEdgeWindowSet {
                 .map(|e| e.into())
                 .collect()
         })
-        .await
+        .await)
     }
 
-    async fn list(&self) -> Vec<GqlEdge> {
+    /// Materialise every window as a list. Rejected by the server when bulk list
+    /// endpoints are disabled; use `page` for paginated access instead.
+    async fn list(&self, ctx: &Context<'_>) -> async_graphql::Result<Vec<GqlEdge>> {
+        check_list_allowed(ctx)?;
         let self_clone = self.clone();
-        blocking_compute(move || self_clone.ws.clone().map(|e| e.into()).collect()).await
+        Ok(blocking_compute(move || self_clone.ws.clone().map(|e| e.into()).collect()).await)
     }
 }
 
+/// A lazy sequence of per-window edge collections, produced by
+/// `edges.rolling` / `edges.expanding`. Each entry is an `Edges` collection
+/// as it exists in that window.
 #[derive(ResolvedObject, Clone)]
 #[graphql(name = "EdgesWindowSet")]
 pub(crate) struct GqlEdgesWindowSet {
@@ -291,6 +378,8 @@ impl GqlEdgesWindowSet {
 }
 #[ResolvedObjectFields]
 impl GqlEdgesWindowSet {
+    /// Number of windows in this set. Materialising all windows is expensive for
+    /// large graphs — prefer `page` over `list` when iterating.
     async fn count(&self) -> usize {
         let self_clone = self.clone();
         blocking_compute(move || self_clone.ws.clone().count()).await
@@ -301,14 +390,21 @@ impl GqlEdgesWindowSet {
     ///
     /// For example, if page(5, 2, 1) is called, a page with 5 items, offset by 11 items (2 pages of 5 + 1),
     /// will be returned.
+
     async fn page(
         &self,
-        limit: usize,
+        ctx: &Context<'_>,
+        #[graphql(desc = "Maximum number of items to return on this page.")] limit: usize,
+        #[graphql(desc = "Extra items to skip on top of `pageIndex` paging (default 0).")]
         offset: Option<usize>,
+        #[graphql(
+            desc = "Zero-based page number; multiplies `limit` to determine where to start (default 0)."
+        )]
         page_index: Option<usize>,
-    ) -> Vec<GqlEdges> {
+    ) -> async_graphql::Result<Vec<GqlEdges>> {
+        check_page_limit(ctx, limit)?;
         let self_clone = self.clone();
-        blocking_compute(move || {
+        Ok(blocking_compute(move || {
             let start = page_index.unwrap_or(0) * limit + offset.unwrap_or(0);
             self_clone
                 .ws
@@ -318,11 +414,17 @@ impl GqlEdgesWindowSet {
                 .map(|e| GqlEdges::new(e))
                 .collect()
         })
-        .await
+        .await)
     }
 
-    async fn list(&self) -> Vec<GqlEdges> {
+    /// Materialise every window as a list. Rejected by the server when bulk list
+    /// endpoints are disabled; use `page` for paginated access instead.
+    async fn list(&self, ctx: &Context<'_>) -> async_graphql::Result<Vec<GqlEdges>> {
+        check_list_allowed(ctx)?;
         let self_clone = self.clone();
-        blocking_compute(move || self_clone.ws.clone().map(|e| GqlEdges::new(e)).collect()).await
+        Ok(
+            blocking_compute(move || self_clone.ws.clone().map(|e| GqlEdges::new(e)).collect())
+                .await,
+        )
     }
 }
diff --git a/raphtory-graphql/src/model/mod.rs b/raphtory-graphql/src/model/mod.rs
index 1f23566bce..de734a771a 100644
--- a/raphtory-graphql/src/model/mod.rs
+++ b/raphtory-graphql/src/model/mod.rs
@@ -1,28 +1,45 @@
 use crate::{
-    auth::ContextValidation,
+    auth::{AuthError, ContextValidation},
+    auth_policy::{AuthPolicyError, AuthorizationPolicy, GraphPermission, NamespacePermission},
     data::Data,
     model::{
         graph::{
-            collection::GqlCollection, graph::GqlGraph, index::IndexSpecInput,
-            mutable_graph::GqlMutableGraph, namespace::Namespace,
+            collection::GqlCollection,
+            filtering::{GqlEdgeFilter, GqlNodeFilter, GraphAccessFilter},
+            graph::GqlGraph,
+            index::IndexSpecInput,
+            meta_graph::MetaGraph,
+            mutable_graph::GqlMutableGraph,
+            namespace::Namespace,
+            namespaced_item::NamespacedItem,
+            node_id::GqlNodeId,
             vectorised_graph::GqlVectorisedGraph,
         },
-        plugins::{mutation_plugin::MutationPlugin, query_plugin::QueryPlugin},
+        plugins::{
+            mutation_plugin::MutationPlugin, query_plugin::QueryPlugin, PermissionsEntrypointMut,
+            PermissionsEntrypointQuery,
+        },
     },
-    paths::{valid_path, ExistingGraphFolder},
+    paths::{ExistingGraphFolder, ValidGraphPaths, ValidWriteableGraphFolder},
     rayon::blocking_compute,
-    url_encode::{url_decode_graph, url_encode_graph},
+    url_encode::{url_decode_graph_at, url_encode_graph},
 };
 use async_graphql::Context;
 use dynamic_graphql::{
     App, Enum, InputObject, Mutation, MutationFields, MutationRoot, OneOfInput, ResolvedObject,
     ResolvedObjectFields, Result, Upload,
 };
+use itertools::Itertools;
 use raphtory::{
-    db::{api::view::MaterializedGraph, graph::views::deletion_graph::PersistentGraph},
-    errors::{GraphError, GraphResult, InvalidPathReason},
+    db::{
+        api::{
+            storage::storage::{Extension, PersistenceStrategy},
+            view::{DynamicGraph, Filter, IntoDynamic, MaterializedGraph},
+        },
+        graph::views::{deletion_graph::PersistentGraph, filter::model::NodeViewFilterOps},
+    },
+    errors::{GraphError, GraphResult},
     prelude::*,
-    serialise::InternalStableDecode,
     vectors::{
         cache::CachedEmbeddingModel,
         storage::OpenAIEmbeddings,
@@ -30,17 +47,16 @@ use raphtory::{
     },
     version,
 };
-#[cfg(feature = "storage")]
-use raphtory_storage::{core_ops::CoreGraphOps, graph::graph::GraphStorage};
 use std::{
     error::Error,
     fmt::{Display, Formatter},
-    io::Read,
+    future::Future,
+    pin::Pin,
     sync::Arc,
 };
-use zip::ZipArchive;
+use tracing::{error, warn};
 
-pub(crate) mod graph;
+pub mod graph;
 pub mod plugins;
 pub(crate) mod schema;
 pub(crate) mod sorting;
@@ -129,6 +145,246 @@ pub enum GqlGraphType {
     Event,
 }
 
+/// Checks that the caller has at least READ permission for the graph at `path`.
+/// Returns the effective `GraphPermission` (including any stored filter) on success.
+/// When denied and the caller has no INTROSPECT on the parent namespace, returns a
+/// "Graph does not exist" error to avoid leaking that the graph is present.
+fn require_at_least_read(
+    ctx: &Context<'_>,
+    policy: &Option<Arc<dyn AuthorizationPolicy>>,
+    path: &str,
+) -> async_graphql::Result<GraphPermission> {
+    if let Some(policy) = policy {
+        let role = ctx.data::<Option<String>>().ok().and_then(|r| r.as_deref());
+        match policy.graph_permissions(ctx, path) {
+            Err(msg) => {
+                let ns = parent_namespace(path);
+                if policy.namespace_permissions(ctx, ns) >= NamespacePermission::Introspect {
+                    warn!(
+                        role = role.unwrap_or("<no role>"),
+                        graph = path,
+                        "Access denied by auth policy"
+                    );
+                    return Err(msg.into());
+                } else {
+                    // Don't leak graph existence — act as if it doesn't exist.
+                    return Err(async_graphql::Error::new(MissingGraph.to_string()));
+                }
+            }
+            Ok(perm) => {
+                if let Some(p) = perm.at_least_read() {
+                    return Ok(p);
+                } else {
+                    warn!(
+                        role = role.unwrap_or("<no role>"),
+                        graph = path,
+                        "Introspect-only access — graph() denied; use graphMetadata() instead"
+                    );
+                    return Err(async_graphql::Error::new(format!(
+                        "Access denied: role '{}' has introspect-only access to graph '{path}' — \
+                         use graphMetadata(path:) for counts and timestamps, or namespace listings to browse graphs",
+                        role.unwrap_or("<no role>")
+                    )));
+                }
+            }
+        }
+    }
+    Ok(GraphPermission::Write)
+}
+
+/// Applies a stored data filter (serialised as `serde_json::Value` with optional `node`, `edge`,
+/// `graph` keys) to a `DynamicGraph`, returning a new filtered view.
+fn apply_graph_filter(
+    mut graph: DynamicGraph,
+    filter: GraphAccessFilter,
+) -> Pin<Box<dyn Future<Output = async_graphql::Result<DynamicGraph>> + Send>> {
+    Box::pin(async move {
+        use raphtory::db::graph::views::filter::model::{
+            edge_filter::CompositeEdgeFilter, node_filter::CompositeNodeFilter, DynView,
+        };
+
+        match filter {
+            GraphAccessFilter::Node(gql_filter) => {
+                let raphtory_filter = CompositeNodeFilter::try_from(gql_filter).map_err(|e| {
+                    error!(error = %e, "node filter conversion failed");
+                    async_graphql::Error::new("internal error applying access filter")
+                })?;
+                graph = blocking_compute({
+                    let g = graph.clone();
+                    move || g.filter(raphtory_filter)
+                })
+                .await
+                .map_err(|e| {
+                    error!(error = %e, "node filter apply failed");
+                    async_graphql::Error::new("internal error applying access filter")
+                })?
+                .into_dynamic();
+            }
+            GraphAccessFilter::Edge(gql_filter) => {
+                let raphtory_filter = CompositeEdgeFilter::try_from(gql_filter).map_err(|e| {
+                    error!(error = %e, "edge filter conversion failed");
+                    async_graphql::Error::new("internal error applying access filter")
+                })?;
+                graph = blocking_compute({
+                    let g = graph.clone();
+                    move || g.filter(raphtory_filter)
+                })
+                .await
+                .map_err(|e| {
+                    error!(error = %e, "edge filter apply failed");
+                    async_graphql::Error::new("internal error applying access filter")
+                })?
+                .into_dynamic();
+            }
+            GraphAccessFilter::Graph(gql_filter) => {
+                let dyn_view = DynView::try_from(gql_filter).map_err(|e| {
+                    error!(error = %e, "graph filter conversion failed");
+                    async_graphql::Error::new("internal error applying access filter")
+                })?;
+                graph = blocking_compute({
+                    let g = graph.clone();
+                    move || g.filter(dyn_view)
+                })
+                .await
+                .map_err(|e| {
+                    error!(error = %e, "graph filter apply failed");
+                    async_graphql::Error::new("internal error applying access filter")
+                })?
+                .into_dynamic();
+            }
+            GraphAccessFilter::And(filters) => {
+                for f in filters {
+                    graph = apply_graph_filter(graph, f).await?;
+                }
+            }
+            GraphAccessFilter::Or(filters) => {
+                // Group same-type sub-filters and combine with native Or;
+                // cross-type sub-filters are applied as independent restrictions.
+                let mut node_fs: Vec<GqlNodeFilter> = vec![];
+                let mut edge_fs: Vec<GqlEdgeFilter> = vec![];
+                let mut rest: Vec<GraphAccessFilter> = vec![];
+                for f in filters {
+                    match f {
+                        GraphAccessFilter::Node(n) => node_fs.push(n),
+                        GraphAccessFilter::Edge(e) => edge_fs.push(e),
+                        other => rest.push(other),
+                    }
+                }
+                if !node_fs.is_empty() {
+                    let combined = if node_fs.len() == 1 {
+                        node_fs.pop().unwrap()
+                    } else {
+                        GqlNodeFilter::Or(node_fs)
+                    };
+                    graph = apply_graph_filter(graph, GraphAccessFilter::Node(combined)).await?;
+                }
+                if !edge_fs.is_empty() {
+                    let combined = if edge_fs.len() == 1 {
+                        edge_fs.pop().unwrap()
+                    } else {
+                        GqlEdgeFilter::Or(edge_fs)
+                    };
+                    graph = apply_graph_filter(graph, GraphAccessFilter::Edge(combined)).await?;
+                }
+                for f in rest {
+                    graph = apply_graph_filter(graph, f).await?;
+                }
+            }
+        }
+
+        Ok(graph)
+    })
+}
+
+/// Returns the namespace portion of a graph path: everything before the last `/`.
+/// For top-level graphs (no `/`), returns `""` (the root namespace).
+fn parent_namespace(path: &str) -> &str {
+    path.rfind('/').map(|i| &path[..i]).unwrap_or("")
+}
+
+fn write_denied(role: Option<&str>, msg: impl std::fmt::Display) -> async_graphql::Error {
+    match role {
+        Some(_) => async_graphql::Error::new(msg.to_string()),
+        None => AuthError::RequireWrite.into(),
+    }
+}
+
+fn require_graph_write(
+    ctx: &Context<'_>,
+    policy: &Option<Arc<dyn AuthorizationPolicy>>,
+    path: &str,
+) -> async_graphql::Result<()> {
+    match policy {
+        None => ctx.require_jwt_write_access().map_err(Into::into),
+        Some(p) => {
+            let role = ctx.data::<Option<String>>().ok().and_then(|r| r.as_deref());
+            p.graph_permissions(ctx, path)
+                .map_err(async_graphql::Error::from)?
+                .at_least_write()
+                .ok_or_else(|| {
+                    write_denied(
+                        role,
+                        format!("Access denied: WRITE permission required for graph '{path}'"),
+                    )
+                })?;
+            Ok(())
+        }
+    }
+}
+
+fn require_namespace_write(
+    ctx: &Context<'_>,
+    policy: &Option<Arc<dyn AuthorizationPolicy>>,
+    ns_path: &str,
+    new_path: &str,
+    operation: &str,
+) -> async_graphql::Result<()> {
+    match policy {
+        None => ctx.require_jwt_write_access().map_err(Into::into),
+        Some(p) => {
+            let role = ctx.data::<Option<String>>().ok().and_then(|r| r.as_deref());
+            if p.namespace_permissions(ctx, ns_path) < NamespacePermission::Write {
+                return Err(write_denied(
+                    role,
+                    format!("Access denied: WRITE required on namespace '{ns_path}' to {operation} graph '{new_path}'"),
+                ));
+            }
+            Ok(())
+        }
+    }
+}
+
+fn require_graph_read_src(
+    ctx: &Context<'_>,
+    policy: &Option<Arc<dyn AuthorizationPolicy>>,
+    path: &str,
+    operation: &str,
+) -> async_graphql::Result<()> {
+    match policy {
+        None => ctx.require_jwt_write_access().map_err(Into::into),
+        Some(p) => {
+            let role = ctx.data::<Option<String>>().ok().and_then(|r| r.as_deref());
+            p.graph_permissions(ctx, path)
+                .map_err(async_graphql::Error::from)?
+                .at_least_read()
+                .ok_or_else(|| {
+                    write_denied(
+                        role,
+                        format!(
+                            "Access denied: READ required on source graph '{path}' to {operation}"
+                        ),
+                    )
+                })?;
+            Ok(())
+        }
+    }
+}
+
+/// Top-level READ-only query root. Entry points for loading a graph
+/// (`graph`, `graphMetadata`), browsing stored graphs (`namespaces`,
+/// `namespace`, `root`), downloading a stored graph as a base64 blob
+/// (`receiveGraph`), inspecting vectorised variants (`vectorisedGraph`),
+/// and a few utility endpoints (`version`, `hello`, `plugins`).
 #[derive(ResolvedObject)]
 #[graphql(root)]
 pub(crate) struct QueryRoot;
@@ -151,45 +407,137 @@ fn resolve(template: Option<Template>, default: &str) -> Option<String> {
 
 #[ResolvedObjectFields]
 impl QueryRoot {
-    /// Hello world demo
+    /// Liveness check — returns a static "hello world" string. Useful for
+    /// smoke-testing that the GraphQL server is reachable.
     async fn hello() -> &'static str {
         "Hello world from raphtory-graphql"
     }
 
-    /// Returns a graph
-    async fn graph<'a>(ctx: &Context<'a>, path: &str) -> Result<GqlGraph> {
+    /// Load a graph by path. Returns null if the graph doesn't exist or is
+    /// inaccessible. When a READ-scoped filter is attached to the caller's
+    /// permissions, that filter is applied before the graph is returned.
+    /// `graphType` lets you re-interpret the stored graph at query time —
+    /// e.g. read an event-stored graph through persistent semantics. Defaults
+    /// to the type the graph was created with.
+    /// Requires READ on the graph.
+
+    async fn graph<'a>(
+        ctx: &Context<'a>,
+        #[graphql(
+            desc = "Graph path relative to the root namespace (e.g. `\"master\"` or `\"team/project/graph\"`)."
+        )]
+        path: &str,
+        #[graphql(
+            desc = "Optional override for graph semantics — `EVENT` treats every update as a point-in-time event, `PERSISTENT` carries values forward until overwritten or deleted. Defaults to the stored graph's native type."
+        )]
+        graph_type: Option<GqlGraphType>,
+    ) -> Result<Option<GqlGraph>> {
         let data = ctx.data_unchecked::<Data>();
-        Ok(data
-            .get_graph(path)
-            .await
-            .map(|(g, folder)| GqlGraph::new(folder, g.graph))?)
+
+        // Permission check: Err (denied or introspect-only) is converted to Ok(None) so the
+        // user sees null — indistinguishable from "graph not found". Warnings are logged inside
+        // require_at_least_read for cases where the user has namespace INTROSPECT visibility.
+        let perms = match require_at_least_read(ctx, &data.auth_policy, path) {
+            Ok(p) => p,
+            Err(_) => return Ok(None),
+        };
+
+        let graph_with_vecs = data.get_graph(path).await?;
+        let materialized = match graph_type {
+            Some(GqlGraphType::Event) => match graph_with_vecs.graph {
+                MaterializedGraph::EventGraph(g) => MaterializedGraph::EventGraph(g),
+                MaterializedGraph::PersistentGraph(g) => {
+                    MaterializedGraph::EventGraph(g.event_graph())
+                }
+            },
+            Some(GqlGraphType::Persistent) => match graph_with_vecs.graph {
+                MaterializedGraph::EventGraph(g) => {
+                    MaterializedGraph::PersistentGraph(g.persistent_graph())
+                }
+                MaterializedGraph::PersistentGraph(g) => MaterializedGraph::PersistentGraph(g),
+            },
+            None => graph_with_vecs.graph,
+        };
+        let graph: DynamicGraph = materialized.into_dynamic();
+
+        let graph = if let GraphPermission::Read {
+            filter: Some(ref f),
+        } = perms
+        {
+            apply_graph_filter(graph, f.clone()).await?
+        } else {
+            graph
+        };
+
+        Ok(Some(GqlGraph::new(graph_with_vecs.folder, graph)))
     }
 
-    /// Update graph query, has side effects to update graph state
-    ///
-    /// Returns:: GqlMutableGraph
-    async fn update_graph<'a>(ctx: &Context<'a>, path: String) -> Result<GqlMutableGraph> {
-        ctx.require_write_access()?;
+    /// Returns lightweight metadata for a graph (node/edge counts,
+    /// timestamps) without deserialising the full graph. Returns null if the
+    /// graph doesn't exist or is inaccessible.
+    /// Requires READ on the graph, or INTROSPECT on its parent namespace.
+
+    async fn graph_metadata<'a>(
+        ctx: &Context<'a>,
+        #[graphql(desc = "Graph path relative to the root namespace.")] path: String,
+    ) -> Result<Option<MetaGraph>> {
         let data = ctx.data_unchecked::<Data>();
 
-        let graph = data
-            .get_graph(path.as_ref())
-            .await
-            .map(|(g, folder)| GqlMutableGraph::new(folder, g))?;
+        if let Some(policy) = &data.auth_policy {
+            let role = ctx.data::<Option<String>>().ok().and_then(|r| r.as_deref());
+            if let Err(_) = policy.graph_permissions(ctx, &path) {
+                let ns = parent_namespace(&path);
+                if policy.namespace_permissions(ctx, ns) >= NamespacePermission::Introspect {
+                    warn!(
+                        role = role.unwrap_or("<no role>"),
+                        graph = path.as_str(),
+                        "Access denied by auth policy"
+                    );
+                }
+                // Always return null — permission denial is indistinguishable from "not found"
+                // from the user's perspective. The warning above is the only signal in the logs.
+                return Ok(None);
+            }
+        }
+
+        let folder = ExistingGraphFolder::try_from(data.work_dir.clone(), &path)
+            .map_err(|e| async_graphql::Error::new(e.to_string()))?;
+        Ok(Some(MetaGraph::new(folder)))
+    }
+
+    /// Open a graph for writing — returns a `MutableGraph` handle that can
+    /// add nodes/edges/properties/metadata.
+    /// Requires WRITE on the graph.
+
+    async fn update_graph<'a>(
+        ctx: &Context<'a>,
+        #[graphql(desc = "Graph path relative to the root namespace.")] path: String,
+    ) -> Result<GqlMutableGraph> {
+        let data = ctx.data_unchecked::<Data>();
+        require_graph_write(ctx, &data.auth_policy, &path)?;
+
+        let graph = data.get_graph(path.as_ref()).await?.into();
+
         Ok(graph)
     }
 
-    /// Update graph query, has side effects to update graph state
-    ///
-    /// Returns:: GqlMutableGraph
+    /// Compute and persist embeddings for the nodes and edges of a stored
+    /// graph so it can be queried via `vectorisedGraph`.
+    /// Requires WRITE access.
+
     async fn vectorise_graph<'a>(
         ctx: &Context<'a>,
-        path: String,
+        #[graphql(desc = "Graph path relative to the root namespace.")] path: String,
+        #[graphql(desc = "Optional embedding model; defaults to OpenAI's standard model.")]
         model: Option<EmbeddingModel>,
+        #[graphql(
+            desc = "Optional node-document template (which fields go into each node's text representation); defaults to the built-in template."
+        )]
         nodes: Option<Template>,
+        #[graphql(desc = "Optional edge-document template; defaults to the built-in template.")]
         edges: Option<Template>,
     ) -> Result<bool> {
-        ctx.require_write_access()?;
+        ctx.require_jwt_write_access()?;
         let data = ctx.data_unchecked::<Data>();
         let template = DocumentTemplate {
             node_template: resolve(nodes, DEFAULT_NODE_TEMPLATE),
@@ -205,61 +553,102 @@ impl QueryRoot {
         Ok(true)
     }
 
-    /// Create vectorised graph in the format used for queries
-    ///
-    /// Returns:: GqlVectorisedGraph
-    async fn vectorised_graph<'a>(ctx: &Context<'a>, path: &str) -> Option<GqlVectorisedGraph> {
+    /// Open a previously-vectorised graph for similarity queries. Returns null
+    /// if the graph has no embeddings (call `vectoriseGraph` first) or is
+    /// inaccessible.
+    /// Requires READ on the graph.
+
+    async fn vectorised_graph<'a>(
+        ctx: &Context<'a>,
+        #[graphql(desc = "Graph path relative to the root namespace.")] path: &str,
+    ) -> Result<Option<GqlVectorisedGraph>> {
         let data = ctx.data_unchecked::<Data>();
-        let g = data.get_graph(path).await.ok()?.0.vectors?;
-        Some(g.into())
+        require_at_least_read(ctx, &data.auth_policy, path)?;
+        Ok(data
+            .get_graph(path)
+            .await
+            .ok()
+            .and_then(|g| g.vectors)
+            .map(|v| v.into()))
     }
-    /// Returns all namespaces using recursive search
-    ///
-    /// Returns::  List of namespaces on root
+
+    /// Recursively list every namespace under the root. Each namespace is
+    /// filtered against the caller's permissions: only namespaces with at
+    /// least DISCOVER are returned.
     async fn namespaces<'a>(ctx: &Context<'a>) -> GqlCollection<Namespace> {
         let data = ctx.data_unchecked::<Data>();
-        let root = Namespace::new(data.work_dir.clone(), data.work_dir.clone());
-        GqlCollection::new(root.get_all_namespaces().into())
+        let root = Namespace::root(data.work_dir.clone());
+        let list = blocking_compute(move || {
+            root.get_all_children()
+                .filter_map(|child| match child {
+                    NamespacedItem::Namespace(item) => Some(item),
+                    NamespacedItem::MetaGraph(_) => None,
+                })
+                .sorted()
+                .collect()
+        })
+        .await;
+        GqlCollection::new(list)
     }
 
-    /// Returns a specific namespace at a given path
-    ///
-    /// Returns:: Namespace or error if no namespace found
+    /// Return a specific namespace by path. Errors if no namespace exists at
+    /// that path.
+    /// Requires INTROSPECT on the namespace to browse its contents.
+
     async fn namespace<'a>(
         ctx: &Context<'a>,
+        #[graphql(
+            desc = "Namespace path relative to the root namespace (e.g. `\"team/project\"`)."
+        )]
         path: String,
-    ) -> Result<Namespace, InvalidPathReason> {
+    ) -> Result<Namespace> {
         let data = ctx.data_unchecked::<Data>();
-        let current_dir = valid_path(data.work_dir.clone(), path.as_str(), true)?;
-
-        if current_dir.exists() {
-            Ok(Namespace::new(data.work_dir.clone(), current_dir))
-        } else {
-            Err(InvalidPathReason::NamespaceDoesNotExist(path))
-        }
+        Ok(Namespace::try_new(data.work_dir.clone(), path)?)
     }
-    /// Returns root namespace
-    ///
-    /// Returns::  Root namespace
+
+    /// Returns the root namespace. Use it as the entry point for browsing
+    /// namespaces and graphs — child listings filter against the caller's
+    /// permissions.
     async fn root<'a>(ctx: &Context<'a>) -> Namespace {
         let data = ctx.data_unchecked::<Data>();
-        Namespace::new(data.work_dir.clone(), data.work_dir.clone())
+        Namespace::root(data.work_dir.clone())
     }
-    /// Returns a plugin.
+
+    /// Entry point for READ-only plugins registered with the server (e.g. graph
+    /// algorithms exposed as queries). Available plugins are defined at server
+    /// startup via the plugin registry.
     async fn plugins<'a>() -> QueryPlugin {
         QueryPlugin::default()
     }
-    /// Encodes graph and returns as string
-    ///
-    /// Returns:: Base64 url safe encoded string
-    async fn receive_graph<'a>(ctx: &Context<'a>, path: String) -> Result<String, Arc<GraphError>> {
-        let path = path.as_ref();
+
+    /// Encode a stored graph as a base64 string for client-side download. If
+    /// a READ-scoped filter is attached to the caller's permissions, only the
+    /// materialised filtered view is encoded.
+    /// Requires READ on the graph.
+
+    async fn receive_graph<'a>(
+        ctx: &Context<'a>,
+        #[graphql(desc = "Graph path relative to the root namespace.")] path: String,
+    ) -> Result<String> {
         let data = ctx.data_unchecked::<Data>();
-        let g = data.get_graph(path).await?.0.graph.clone();
-        let res = url_encode_graph(g)?;
+        let perm = require_at_least_read(ctx, &data.auth_policy, &path)?;
+        let raw = data.get_graph(&path).await?.graph;
+        let res = if let GraphPermission::Read {
+            filter: Some(ref f),
+        } = perm
+        {
+            let filtered = apply_graph_filter(raw.into_dynamic(), f.clone()).await?;
+            let materialized = blocking_compute(move || filtered.materialize())
+                .await
+                .map_err(|e| async_graphql::Error::new(e.to_string()))?;
+            url_encode_graph(materialized)?
+        } else {
+            url_encode_graph(raw)?
+        };
         Ok(res)
     }
 
+    /// Version string of the running `raphtory-graphql` server build.
     async fn version<'a>(_ctx: &Context<'a>) -> String {
         String::from(version())
     }
@@ -278,138 +667,208 @@ impl Mut {
         MutationPlugin::default()
     }
 
-    /// Delete graph from a path on the server.
-    // If namespace is not provided, it will be set to the current working directory.
-    async fn delete_graph<'a>(ctx: &Context<'a>, path: String) -> Result<bool> {
+    /// Permanently delete a stored graph from the server.
+    /// Requires WRITE on the graph and on its parent namespace.
+
+    async fn delete_graph<'a>(
+        ctx: &Context<'a>,
+        #[graphql(desc = "Graph path relative to the root namespace.")] path: String,
+    ) -> Result<bool> {
         let data = ctx.data_unchecked::<Data>();
+        require_graph_write(ctx, &data.auth_policy, &path)?;
+        let src_ns = parent_namespace(&path);
+        require_namespace_write(ctx, &data.auth_policy, src_ns, &path, "delete")?;
         data.delete_graph(&path).await?;
         Ok(true)
     }
 
-    /// Creates a new graph.
+    /// Create a new empty graph at the given path. Errors if a graph already
+    /// exists there.
+    /// Requires WRITE on the parent namespace.
+
     async fn new_graph<'a>(
         ctx: &Context<'a>,
-        path: String,
+        #[graphql(desc = "Destination path relative to the root namespace.")] path: String,
         graph_type: GqlGraphType,
     ) -> Result<bool> {
         let data = ctx.data_unchecked::<Data>();
-        let graph = match graph_type {
-            GqlGraphType::Persistent => PersistentGraph::new().materialize()?,
-            GqlGraphType::Event => Graph::new().materialize()?,
+        let ns = parent_namespace(&path);
+        require_namespace_write(ctx, &data.auth_policy, ns, &path, "create")?;
+        let overwrite = false;
+        let folder = data.validate_path_for_insert(&path, overwrite)?;
+        let graph_path = folder.graph_folder();
+        let graph: MaterializedGraph = if Extension::disk_storage_enabled() {
+            match graph_type {
+                GqlGraphType::Persistent => PersistentGraph::new_at_path(graph_path)?.into(),
+                GqlGraphType::Event => Graph::new_at_path(graph_path)?.into(),
+            }
+        } else {
+            match graph_type {
+                GqlGraphType::Persistent => PersistentGraph::new().into(),
+                GqlGraphType::Event => Graph::new().into(),
+            }
         };
-        data.insert_graph(&path, graph).await?;
+
+        data.insert_graph(folder, graph).await?;
+
         Ok(true)
     }
 
-    /// Move graph from a path path on the server to a new_path on the server.
-    ///
-    /// If namespace is not provided, it will be set to the current working directory.
-    /// This applies to both the graph namespace and new graph namespace.
-    async fn move_graph<'a>(ctx: &Context<'a>, path: &str, new_path: &str) -> Result<bool> {
-        Self::copy_graph(ctx, path, new_path).await?;
+    /// Move a stored graph to a new path on the server (rename / relocate).
+    /// Atomic: copies first, then deletes the source.
+    /// Requires WRITE on the source graph and on both the source and
+    /// destination namespaces.
+
+    async fn move_graph<'a>(
+        ctx: &Context<'a>,
+        #[graphql(desc = "Current graph path relative to the root namespace.")] path: &str,
+        #[graphql(desc = "Destination path relative to the root namespace.")] new_path: &str,
+        #[graphql(
+            desc = "If true, allow replacing an existing graph at `newPath`; defaults to false."
+        )]
+        overwrite: Option<bool>,
+    ) -> Result<bool> {
         let data = ctx.data_unchecked::<Data>();
+        // src: require WRITE on graph (moving = deleting source)
+        require_graph_write(ctx, &data.auth_policy, path)?;
+        // src: require WRITE on parent namespace (removing graph from namespace)
+        let src_ns = parent_namespace(path);
+        require_namespace_write(ctx, &data.auth_policy, src_ns, path, "move")?;
+        // copy_graph handles dst namespace WRITE check (and src READ, which WRITE implies)
+        Self::copy_graph(ctx, path, new_path, overwrite).await?;
         data.delete_graph(path).await?;
         Ok(true)
     }
 
-    /// Copy graph from a path path on the server to a new_path on the server.
-    ///
-    /// If namespace is not provided, it will be set to the current working directory.
-    /// This applies to both the graph namespace and new graph namespace.
-    async fn copy_graph<'a>(ctx: &Context<'a>, path: &str, new_path: &str) -> Result<bool> {
+    /// Duplicate a stored graph to a new path on the server. Source is
+    /// preserved.
+    /// Requires READ on the source graph and WRITE on the destination namespace.
+
+    async fn copy_graph<'a>(
+        ctx: &Context<'a>,
+        #[graphql(desc = "Source graph path relative to the root namespace.")] path: &str,
+        #[graphql(desc = "Destination path relative to the root namespace.")] new_path: &str,
+        #[graphql(
+            desc = "If true, allow replacing an existing graph at `newPath`; defaults to false."
+        )]
+        overwrite: Option<bool>,
+    ) -> Result<bool> {
+        let data = ctx.data_unchecked::<Data>();
+        require_graph_read_src(ctx, &data.auth_policy, path, "copy it")?;
+        let dst_ns = parent_namespace(new_path);
+        require_namespace_write(ctx, &data.auth_policy, dst_ns, new_path, "create")?;
         // doing this in a more efficient way is not trivial, this at least is correct
         // there are questions like, maybe the new vectorised graph have different rules
         // for the templates or if it needs to be vectorised at all
-        let data = ctx.data_unchecked::<Data>();
-        let graph = data.get_graph(path).await?.0.graph;
-
-        #[cfg(feature = "storage")]
-        if let GraphStorage::Disk(_) = graph.core_graph() {
-            return Err(GqlGraphError::ImmutableDiskGraph.into());
-        }
-        data.insert_graph(new_path, graph).await?;
+        let overwrite = overwrite.unwrap_or(false);
+        let graph = data.get_graph(path).await?.graph;
+        let folder = data.validate_path_for_insert(new_path, overwrite)?;
+        data.insert_graph(folder, graph).await?;
 
         Ok(true)
     }
 
-    /// Upload a graph file from a path on the client using GQL multipart uploading.
-    ///
-    /// Returns::
-    /// name of the new graph
+    /// Stream-upload a graph file using GraphQL multipart upload. The client
+    /// sends the file directly; the server stores it under `path`.
+    /// Requires WRITE on the destination namespace.
+
     async fn upload_graph<'a>(
         ctx: &Context<'a>,
-        path: String,
-        graph: Upload,
-        overwrite: bool,
+        #[graphql(desc = "Destination path relative to the root namespace.")] path: String,
+        #[graphql(desc = "Multipart upload of the serialised graph file.")] graph: Upload,
+        #[graphql(desc = "If true, replace any graph already at `path`.")] overwrite: bool,
     ) -> Result<String> {
         let data = ctx.data_unchecked::<Data>();
-        let graph = {
-            let in_file = graph.value(ctx)?.content;
-            let mut archive = ZipArchive::new(in_file)?;
-            let mut entry = archive.by_name("graph")?;
-            let mut buf = vec![];
-            entry.read_to_end(&mut buf)?;
-            MaterializedGraph::decode_from_bytes(&buf)?
-        };
-        if overwrite {
-            let _ignored = data.delete_graph(&path).await;
-        }
-        data.insert_graph(&path, graph).await?;
+        let dst_ns = parent_namespace(&path);
+        require_namespace_write(ctx, &data.auth_policy, dst_ns, &path, "upload")?;
+        let in_file = graph.value(ctx)?.content;
+        let folder = data.validate_path_for_insert(&path, overwrite)?;
+        data.insert_graph_as_bytes(folder, in_file).await?;
+
         Ok(path)
     }
 
-    /// Send graph bincode as base64 encoded string.
-    ///
-    /// Returns::
-    /// path of the new graph
+    /// Send a serialised graph as a base64-encoded string in the request
+    /// body. Use for smaller graphs where multipart upload is overkill.
+    /// Requires WRITE on the destination namespace.
+
     async fn send_graph<'a>(
         ctx: &Context<'a>,
-        path: &str,
-        graph: String,
-        overwrite: bool,
+        #[graphql(desc = "Destination path relative to the root namespace.")] path: &str,
+        #[graphql(desc = "Base64-encoded bincode of the serialised graph.")] graph: String,
+        #[graphql(desc = "If true, replace any graph already at `path`.")] overwrite: bool,
     ) -> Result<String> {
         let data = ctx.data_unchecked::<Data>();
-        let g: MaterializedGraph = url_decode_graph(graph)?;
-        if overwrite {
-            let _ignored = data.delete_graph(path).await;
-        }
-        data.insert_graph(path, g).await?;
+        let dst_ns = parent_namespace(path);
+        require_namespace_write(ctx, &data.auth_policy, dst_ns, path, "send")?;
+        let folder = if overwrite {
+            ValidWriteableGraphFolder::try_existing_or_new(data.work_dir.clone(), path)?
+        } else {
+            ValidWriteableGraphFolder::try_new(data.work_dir.clone(), path)?
+        };
+        let config = data.graph_conf.clone();
+        let folder_clone = folder.clone();
+        let g: MaterializedGraph = blocking_compute(move || {
+            url_decode_graph_at(graph, folder_clone.graph_folder(), config)
+        })
+        .await?;
+        data.insert_graph(folder, g).await?;
         Ok(path.to_owned())
     }
 
-    /// Returns a subgraph given a set of nodes from an existing graph in the server.
-    ///
-    /// Returns::
-    /// name of the new graph
+    /// Persist a subgraph of an existing stored graph as a new graph. The
+    /// subgraph contains only the listed nodes and edges between them.
+    /// Requires READ on the parent graph and WRITE on the destination namespace.
+
     async fn create_subgraph<'a>(
         ctx: &Context<'a>,
-        parent_path: &str,
-        nodes: Vec<String>,
-        new_path: String,
-        overwrite: bool,
+        #[graphql(desc = "Source graph path relative to the root namespace.")] parent_path: &str,
+        #[graphql(desc = "Node ids to include in the subgraph.")] nodes: Vec<GqlNodeId>,
+        #[graphql(desc = "Destination path relative to the root namespace.")] new_path: String,
+        #[graphql(desc = "If true, replace any graph already at `newPath`.")] overwrite: bool,
     ) -> Result<String> {
         let data = ctx.data_unchecked::<Data>();
-        let parent_graph = data.get_graph(parent_path).await?.0.graph;
-        let new_subgraph =
-            blocking_compute(move || parent_graph.subgraph(nodes).materialize()).await?;
-        if overwrite {
-            let _ignored = data.delete_graph(&new_path).await;
-        }
-        data.insert_graph(&new_path, new_subgraph).await?;
+        require_graph_read_src(ctx, &data.auth_policy, parent_path, "create a subgraph")?;
+        let dst_ns = parent_namespace(&new_path);
+        require_namespace_write(ctx, &data.auth_policy, dst_ns, &new_path, "create")?;
+        let folder = data.validate_path_for_insert(&new_path, overwrite)?;
+        let parent_graph = data.get_graph(parent_path).await?.graph;
+        let folder_clone = folder.clone();
+        let new_subgraph = blocking_compute(move || {
+            let subgraph = parent_graph.subgraph(nodes);
+            if Extension::disk_storage_enabled() {
+                subgraph.materialize_at(folder_clone.graph_folder())
+            } else {
+                subgraph.materialize()
+            }
+        })
+        .await?;
+
+        data.insert_graph(folder, new_subgraph).await?;
         Ok(new_path)
     }
 
-    /// (Experimental) Creates search index.
+    /// (Experimental) Build a Tantivy search index for a stored graph so it
+    /// can be queried via `searchNodes` / `searchEdges`.
+    /// Requires WRITE on the graph.
+
     async fn create_index<'a>(
         ctx: &Context<'a>,
-        path: &str,
+        #[graphql(desc = "Graph path relative to the root namespace.")] path: &str,
+        #[graphql(
+            desc = "Optional spec selecting which node/edge property fields to index. Omit to index a default set."
+        )]
         index_spec: Option<IndexSpecInput>,
+        #[graphql(
+            desc = "If true, build the index in memory (faster but lost on restart). If false, persist to disk."
+        )]
         in_ram: bool,
     ) -> Result<bool> {
+        let data = ctx.data_unchecked::<Data>();
+        require_graph_write(ctx, &data.auth_policy, path)?;
         #[cfg(feature = "search")]
         {
-            let data = ctx.data_unchecked::<Data>();
-            let graph = data.get_graph(path).await?.0.graph;
+            let graph = data.get_graph(path).await?.graph;
             match index_spec {
                 Some(index_spec) => {
                     let index_spec = index_spec.to_index_spec(graph.clone())?;
@@ -438,4 +897,10 @@ impl Mut {
 }
 
 #[derive(App)]
-pub struct App(QueryRoot, MutRoot, Mut);
+pub struct App(
+    QueryRoot,
+    MutRoot,
+    Mut,
+    PermissionsEntrypointMut,
+    PermissionsEntrypointQuery,
+);
diff --git a/raphtory-graphql/src/model/plugins/algorithms.rs b/raphtory-graphql/src/model/plugins/algorithms.rs
index b777c472e3..4b67a165d1 100644
--- a/raphtory-graphql/src/model/plugins/algorithms.rs
+++ b/raphtory-graphql/src/model/plugins/algorithms.rs
@@ -24,47 +24,10 @@ pub(crate) struct PagerankOutput {
     rank: f64,
 }
 
-impl From<(String, HashMap<String, Option<Prop>>)> for PagerankOutput {
-    fn from(_value: (String, HashMap<String, Option<Prop>>)) -> Self {
-        todo!()
-    }
-}
-
-impl From<(String, f64)> for PagerankOutput {
-    fn from((name, rank): (String, f64)) -> Self {
-        Self { name, rank }
-    }
-}
-
-impl From<(String, Option<f64>)> for PagerankOutput {
-    fn from((name, rank): (String, Option<f64>)) -> Self {
-        Self {
-            name,
-            rank: rank.unwrap_or_default(), // use 0.0 if rank is None
-        }
-    }
-}
-
-impl From<(String, OrderedFloat<f64>)> for PagerankOutput {
-    fn from((name, rank): (String, OrderedFloat<f64>)) -> Self {
-        let rank = rank.into_inner();
-        Self { name, rank }
-    }
-}
-
-impl From<(&String, &OrderedFloat<f64>)> for PagerankOutput {
-    fn from((name, rank): (&String, &OrderedFloat<f64>)) -> Self {
-        Self {
-            name: name.to_string(),
-            rank: rank.into_inner(),
-        }
-    }
-}
-
 impl From<(String, PageRankState)> for PagerankOutput {
     fn from((name, rank): (String, PageRankState)) -> Self {
         Self {
-            name: name.to_string(),
+            name,
             rank: rank.score,
         }
     }
@@ -91,7 +54,7 @@ impl<'a> Operation<'a, GraphAlgorithmPlugin> for Pagerank {
 
     fn apply<'b>(
         entry_point: &GraphAlgorithmPlugin,
-        ctx: ResolverContext,
+        ctx: ResolverContext<'b>,
     ) -> BoxFuture<'b, FieldResult<Option<FieldValue<'b>>>> {
         let result = apply_pagerank(entry_point, ctx);
         Box::pin(async move { result })
@@ -158,7 +121,7 @@ impl<'a> Operation<'a, GraphAlgorithmPlugin> for ShortestPath {
 
     fn apply<'b>(
         entry_point: &GraphAlgorithmPlugin,
-        ctx: ResolverContext,
+        ctx: ResolverContext<'b>,
     ) -> BoxFuture<'b, FieldResult<Option<FieldValue<'b>>>> {
         let result = apply_shortest_path(entry_point, ctx);
         Box::pin(async move { result })
diff --git a/raphtory-graphql/src/model/plugins/mod.rs b/raphtory-graphql/src/model/plugins/mod.rs
index d499e1d39c..8cab98fafa 100644
--- a/raphtory-graphql/src/model/plugins/mod.rs
+++ b/raphtory-graphql/src/model/plugins/mod.rs
@@ -7,7 +7,36 @@ pub mod graph_algorithm_plugin;
 pub mod mutation_entry_point;
 pub mod mutation_plugin;
 pub mod operation;
+pub mod permissions_entrypoint;
+pub mod permissions_plugin;
 pub mod query_entry_point;
 pub mod query_plugin;
 
+pub use permissions_entrypoint::{PermissionsEntrypointMut, PermissionsEntrypointQuery};
+
 pub type RegisterFunction = Box<dyn FnOnce(&str, Registry, Object) -> (Registry, Object) + Send>;
+
+/// Register an operation into the `PermissionsPlugin` entry point (mutation root).
+/// Call this before `GraphServer::run()` / `create_schema()`.
+pub fn register_permissions_mutation<O>(name: &'static str)
+where
+    O: for<'a> operation::Operation<'a, permissions_plugin::PermissionsPlugin> + 'static,
+{
+    permissions_plugin::PERMISSIONS_MUTATIONS
+        .lock()
+        .unwrap()
+        .insert(name.to_string(), Box::new(O::register_operation));
+}
+
+/// Register an operation into the `PermissionsQueryPlugin` entry point (query root).
+/// Ops registered here must call `require_jwt_write_access_dynamic` themselves since they
+/// are not covered by the `MutationAuth` extension.
+pub fn register_permissions_query<O>(name: &'static str)
+where
+    O: for<'a> operation::Operation<'a, permissions_plugin::PermissionsQueryPlugin> + 'static,
+{
+    permissions_plugin::PERMISSIONS_QUERIES
+        .lock()
+        .unwrap()
+        .insert(name.to_string(), Box::new(O::register_operation));
+}
diff --git a/raphtory-graphql/src/model/plugins/operation.rs b/raphtory-graphql/src/model/plugins/operation.rs
index 144a829b3c..43e7ae51f7 100644
--- a/raphtory-graphql/src/model/plugins/operation.rs
+++ b/raphtory-graphql/src/model/plugins/operation.rs
@@ -17,7 +17,7 @@ pub trait Operation<'a, A: Send + Sync + 'static> {
 
     fn apply<'b>(
         entry_point: &A,
-        ctx: ResolverContext,
+        ctx: ResolverContext<'b>,
     ) -> BoxFuture<'b, FieldResult<Option<FieldValue<'b>>>>;
 
     fn register_operation(name: &str, registry: Registry, parent: Object) -> (Registry, Object) {
@@ -52,7 +52,7 @@ impl<'a> Operation<'a, MutationPlugin> for NoOpMutation {
 
     fn apply<'b>(
         _entry_point: &MutationPlugin,
-        _ctx: ResolverContext,
+        _ctx: ResolverContext<'b>,
     ) -> BoxFuture<'b, FieldResult<Option<FieldValue<'b>>>> {
         Box::pin(async move { Ok(Some(FieldValue::value("no-op".to_owned()))) })
     }
@@ -73,7 +73,7 @@ impl<'a> Operation<'a, QueryPlugin> for NoOpQuery {
 
     fn apply<'b>(
         _entry_point: &QueryPlugin,
-        _ctx: ResolverContext,
+        _ctx: ResolverContext<'b>,
     ) -> BoxFuture<'b, FieldResult<Option<FieldValue<'b>>>> {
         Box::pin(async move { Ok(Some(FieldValue::value("no-op".to_owned()))) })
     }
diff --git a/raphtory-graphql/src/model/plugins/permissions_entrypoint.rs b/raphtory-graphql/src/model/plugins/permissions_entrypoint.rs
new file mode 100644
index 0000000000..18e3235979
--- /dev/null
+++ b/raphtory-graphql/src/model/plugins/permissions_entrypoint.rs
@@ -0,0 +1,61 @@
+use super::permissions_plugin::{
+    PermissionsPlugin, PermissionsQueryPlugin, PERMISSIONS_MUT_ENTRYPOINT,
+    PERMISSIONS_QRY_ENTRYPOINT,
+};
+use crate::auth::require_jwt_write_access_dynamic;
+use async_graphql::dynamic::{Field, FieldFuture, FieldValue, TypeRef};
+use dynamic_graphql::internal::{Register, Registry};
+use std::sync::atomic::Ordering;
+
+/// Conditionally adds the `permissions` field to the root Mutation type.
+/// Only registers when `register_permissions_entrypoint()` has been called
+/// (i.e., when RBAC is configured via `raphtory-auth::init()`).
+pub struct PermissionsEntrypointMut;
+
+/// Conditionally adds the `permissions` field to the root Query type.
+/// Only registers when `register_permissions_query_entrypoint()` has been called.
+pub struct PermissionsEntrypointQuery;
+
+impl Register for PermissionsEntrypointMut {
+    fn register(registry: Registry) -> Registry {
+        if !PERMISSIONS_MUT_ENTRYPOINT.load(Ordering::SeqCst) {
+            return registry;
+        }
+        let registry = registry.register::<PermissionsPlugin>();
+        registry.update_object("MutRoot", "PermissionsEntrypointMut", |obj| {
+            obj.field(Field::new(
+                "permissions",
+                TypeRef::named_nn("PermissionsPlugin"),
+                |ctx| {
+                    FieldFuture::new(async move {
+                        require_jwt_write_access_dynamic(&ctx)?;
+                        Ok(Some(FieldValue::owned_any(PermissionsPlugin::default())))
+                    })
+                },
+            ))
+        })
+    }
+}
+
+impl Register for PermissionsEntrypointQuery {
+    fn register(registry: Registry) -> Registry {
+        if !PERMISSIONS_QRY_ENTRYPOINT.load(Ordering::SeqCst) {
+            return registry;
+        }
+        let registry = registry.register::<PermissionsQueryPlugin>();
+        registry.update_object("QueryRoot", "PermissionsEntrypointQuery", |obj| {
+            obj.field(Field::new(
+                "permissions",
+                TypeRef::named_nn("PermissionsQueryPlugin"),
+                |ctx| {
+                    FieldFuture::new(async move {
+                        require_jwt_write_access_dynamic(&ctx)?;
+                        Ok(Some(FieldValue::owned_any(
+                            PermissionsQueryPlugin::default(),
+                        )))
+                    })
+                },
+            ))
+        })
+    }
+}
diff --git a/raphtory-graphql/src/model/plugins/permissions_plugin.rs b/raphtory-graphql/src/model/plugins/permissions_plugin.rs
new file mode 100644
index 0000000000..187cb9f41a
--- /dev/null
+++ b/raphtory-graphql/src/model/plugins/permissions_plugin.rs
@@ -0,0 +1,96 @@
+use super::RegisterFunction;
+use crate::model::plugins::entry_point::EntryPoint;
+use async_graphql::{dynamic::FieldValue, indexmap::IndexMap, Context};
+use dynamic_graphql::internal::{OutputTypeName, Register, Registry, ResolveOwned, TypeName};
+use once_cell::sync::Lazy;
+use std::{
+    borrow::Cow,
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Mutex, MutexGuard,
+    },
+};
+
+pub(crate) static PERMISSIONS_MUT_ENTRYPOINT: AtomicBool = AtomicBool::new(false);
+pub(crate) static PERMISSIONS_QRY_ENTRYPOINT: AtomicBool = AtomicBool::new(false);
+
+pub fn register_permissions_entrypoint() {
+    PERMISSIONS_MUT_ENTRYPOINT.store(true, Ordering::SeqCst);
+}
+
+pub fn register_permissions_query_entrypoint() {
+    PERMISSIONS_QRY_ENTRYPOINT.store(true, Ordering::SeqCst);
+}
+
+pub static PERMISSIONS_MUTATIONS: Lazy<Mutex<IndexMap<String, RegisterFunction>>> =
+    Lazy::new(|| Mutex::new(IndexMap::new()));
+
+pub static PERMISSIONS_QUERIES: Lazy<Mutex<IndexMap<String, RegisterFunction>>> =
+    Lazy::new(|| Mutex::new(IndexMap::new()));
+
+#[derive(Clone, Default)]
+pub struct PermissionsPlugin;
+
+impl<'a> EntryPoint<'a> for PermissionsPlugin {
+    fn predefined_operations() -> IndexMap<&'static str, RegisterFunction> {
+        IndexMap::new()
+    }
+
+    fn lock_plugins() -> MutexGuard<'static, IndexMap<String, RegisterFunction>> {
+        PERMISSIONS_MUTATIONS.lock().unwrap()
+    }
+}
+
+impl Register for PermissionsPlugin {
+    fn register(registry: Registry) -> Registry {
+        Self::register_operations(registry)
+    }
+}
+
+impl TypeName for PermissionsPlugin {
+    fn get_type_name() -> Cow<'static, str> {
+        "PermissionsPlugin".into()
+    }
+}
+
+impl OutputTypeName for PermissionsPlugin {}
+
+impl<'a> ResolveOwned<'a> for PermissionsPlugin {
+    fn resolve_owned(self, _ctx: &Context) -> dynamic_graphql::Result<Option<FieldValue<'a>>> {
+        Ok(Some(FieldValue::owned_any(self)))
+    }
+}
+
+/// Read-only entry point for permissions queries (admin-gated via require_jwt_write_access_dynamic).
+#[derive(Clone, Default)]
+pub struct PermissionsQueryPlugin;
+
+impl<'a> EntryPoint<'a> for PermissionsQueryPlugin {
+    fn predefined_operations() -> IndexMap<&'static str, RegisterFunction> {
+        IndexMap::new()
+    }
+
+    fn lock_plugins() -> MutexGuard<'static, IndexMap<String, RegisterFunction>> {
+        PERMISSIONS_QUERIES.lock().unwrap()
+    }
+}
+
+impl Register for PermissionsQueryPlugin {
+    fn register(registry: Registry) -> Registry {
+        Self::register_operations(registry)
+    }
+}
+
+impl TypeName for PermissionsQueryPlugin {
+    fn get_type_name() -> Cow<'static, str> {
+        "PermissionsQueryPlugin".into()
+    }
+}
+
+impl OutputTypeName for PermissionsQueryPlugin {}
+
+impl<'a> ResolveOwned<'a> for PermissionsQueryPlugin {
+    fn resolve_owned(self, _ctx: &Context) -> dynamic_graphql::Result<Option<FieldValue<'a>>> {
+        Ok(Some(FieldValue::owned_any(self)))
+    }
+}
diff --git a/raphtory-graphql/src/model/schema/edge_schema.rs b/raphtory-graphql/src/model/schema/edge_schema.rs
index 756f00b1f9..463980db89 100644
--- a/raphtory-graphql/src/model/schema/edge_schema.rs
+++ b/raphtory-graphql/src/model/schema/edge_schema.rs
@@ -13,6 +13,9 @@ use raphtory::{
 use raphtory_api::core::entities::properties::meta::PropMapper;
 use std::collections::HashSet;
 
+/// Describes edges between a specific pair of node types — the property and
+/// metadata keys seen on such edges, along with their observed value types.
+/// One `EdgeSchema` per `(srcType, dstType)` pair per layer.
 #[derive(Clone, ResolvedObject)]
 pub(crate) struct EdgeSchema<G: StaticGraphViewOps> {
     graph: G,
diff --git a/raphtory-graphql/src/model/schema/graph_schema.rs b/raphtory-graphql/src/model/schema/graph_schema.rs
index 30aeeb5d1e..f0c007ae39 100644
--- a/raphtory-graphql/src/model/schema/graph_schema.rs
+++ b/raphtory-graphql/src/model/schema/graph_schema.rs
@@ -12,7 +12,7 @@ pub(crate) struct GraphSchema {
 
 impl GraphSchema {
     pub fn new(graph: &DynamicGraph) -> Self {
-        let node_types = 0..graph.node_meta().node_type_meta().len();
+        let node_types = graph.node_meta().node_type_meta().ids();
         let nodes = node_types
             .map(|node_type| NodeSchema::new(node_type, graph.clone()))
             .collect();
diff --git a/raphtory-graphql/src/model/schema/layer_schema.rs b/raphtory-graphql/src/model/schema/layer_schema.rs
index 1fc7e5cb08..3cfbfa5c3e 100644
--- a/raphtory-graphql/src/model/schema/layer_schema.rs
+++ b/raphtory-graphql/src/model/schema/layer_schema.rs
@@ -6,6 +6,8 @@ use raphtory::{
     prelude::*,
 };
 
+/// Describes a single edge layer — its name and the per `(srcType, dstType)`
+/// edge schemas observed within it.
 #[derive(ResolvedObject)]
 pub(crate) struct LayerSchema<G: StaticGraphViewOps> {
     graph: LayeredGraph<G>,
diff --git a/raphtory-graphql/src/model/schema/node_schema.rs b/raphtory-graphql/src/model/schema/node_schema.rs
index 193b262b93..f499e291ca 100644
--- a/raphtory-graphql/src/model/schema/node_schema.rs
+++ b/raphtory-graphql/src/model/schema/node_schema.rs
@@ -10,9 +10,13 @@ use raphtory::{
     },
     prelude::*,
 };
+use raphtory_api::core::entities::LayerIds;
 use raphtory_storage::core_ops::CoreGraphOps;
 use rayon::prelude::*;
 
+/// Describes nodes of a specific type in a graph — its property keys and
+/// observed value types (and, for string-valued properties, the set of
+/// distinct values seen). One `NodeSchema` per node type.
 #[derive(ResolvedObject)]
 pub(crate) struct NodeSchema {
     pub(crate) type_id: usize,
@@ -30,15 +34,21 @@ impl NodeSchema {
 
 #[ResolvedObjectFields]
 impl NodeSchema {
+    /// The node type this schema describes (e.g. `"person"`, `"org"`).
+    /// Falls back to the default node type for untyped nodes.
     async fn type_name(&self) -> String {
         self.type_name_inner()
     }
 
-    /// Returns the list of property schemas for this node
+    /// Property schemas seen on nodes of this type — one entry per property key
+    /// ever set on a node of this type, with its observed `PropertyType` and (for
+    /// string-valued properties) the set of distinct values.
     async fn properties(&self) -> Vec<PropertySchema> {
         self.properties_inner()
     }
 
+    /// Metadata schemas seen on nodes of this type — like `properties`, but
+    /// covering metadata fields rather than temporal properties.
     async fn metadata(&self) -> Vec<PropertySchema> {
         self.metadata_inner()
     }
@@ -53,24 +63,16 @@ impl NodeSchema {
             .unwrap_or_else(|| DEFAULT_NODE_TYPE.to_string())
     }
     fn properties_inner(&self) -> Vec<PropertySchema> {
-        let keys: Vec<String> = self
+        let (keys, property_types): (Vec<_>, Vec<_>) = self
             .graph
             .node_meta()
             .temporal_prop_mapper()
-            .get_keys()
-            .into_iter()
-            .map(|k| k.to_string())
-            .collect();
-        let property_types: Vec<String> = self
-            .graph
-            .node_meta()
-            .temporal_prop_mapper()
-            .dtypes()
-            .iter()
-            .map(|dtype| dtype.to_string())
-            .collect();
+            .locked()
+            .iter_ids_and_types()
+            .map(|(_, name, dtype)| (name.to_string(), dtype.to_string()))
+            .unzip();
 
-        if self.graph.unfiltered_num_nodes() > 1000 {
+        if self.graph.unfiltered_num_nodes(&LayerIds::All) > 1000 {
             // large graph, do not collect detailed schema as it is expensive
             keys.into_iter()
                 .zip(property_types)
@@ -81,7 +83,7 @@ impl NodeSchema {
                 .zip(property_types)
                 .filter_map(|(key, dtype)| {
                     let mut node_types_filter =
-                        vec![false; self.graph.node_meta().node_type_meta().len()];
+                        vec![false; self.graph.node_meta().node_type_meta().num_all_fields()];
                     node_types_filter[self.type_id] = true;
                     let filter = TypeId.mask(node_types_filter.into());
                     let unique_values: ahash::HashSet<_> =
@@ -108,24 +110,16 @@ impl NodeSchema {
     }
 
     fn metadata_inner(&self) -> Vec<PropertySchema> {
-        let keys: Vec<String> = self
+        let (keys, property_types): (Vec<_>, Vec<_>) = self
             .graph
             .node_meta()
             .metadata_mapper()
-            .get_keys()
-            .into_iter()
-            .map(|k| k.to_string())
-            .collect();
-        let property_types: Vec<String> = self
-            .graph
-            .node_meta()
-            .metadata_mapper()
-            .dtypes()
-            .iter()
-            .map(|dtype| dtype.to_string())
-            .collect();
+            .locked()
+            .iter_ids_and_types()
+            .map(|(_, k, dtype)| (k.to_string(), dtype.to_string()))
+            .unzip();
 
-        if self.graph.unfiltered_num_nodes() > 1000 {
+        if self.graph.unfiltered_num_nodes(&LayerIds::All) > 1000 {
             // large graph, do not collect detailed schema as it is expensive
             keys.into_iter()
                 .zip(property_types)
@@ -136,7 +130,7 @@ impl NodeSchema {
                 .zip(property_types)
                 .filter_map(|(key, dtype)| {
                     let mut node_types_filter =
-                        vec![false; self.graph.node_meta().node_type_meta().len()];
+                        vec![false; self.graph.node_meta().node_type_meta().num_all_fields()];
                     node_types_filter[self.type_id] = true;
                     let filter = TypeId.mask(node_types_filter.into());
                     let unique_values: ahash::HashSet<_> =
@@ -174,15 +168,16 @@ mod test {
 
     #[test]
     fn aggregate_schema() -> Result<(), GraphError> {
-        let g = Graph::new_with_shards(2);
+        let g = Graph::new();
 
         g.add_node(
             0,
             1,
             [("t", Prop::str("wallet")), ("cost", Prop::F64(99.5))],
             Some("a"),
+            None,
         )?;
-        g.add_node(1, 2, [("t", Prop::str("person"))], None)?;
+        g.add_node(1, 2, [("t", Prop::str("person"))], None, None)?;
         g.add_node(
             6,
             3,
@@ -198,6 +193,7 @@ mod test {
                 ("cost_b", Prop::F64(76.0)),
             ],
             Some("b"),
+            None,
         )?;
         g.add_node(
             7,
@@ -207,6 +203,7 @@ mod test {
                 ("bool_prop", Prop::Bool(true)),
             ],
             Some("b"),
+            None,
         )?;
 
         let node = g.node(1).unwrap();
diff --git a/raphtory-graphql/src/paths.rs b/raphtory-graphql/src/paths.rs
index b06a16fd43..b3f8093663 100644
--- a/raphtory-graphql/src/paths.rs
+++ b/raphtory-graphql/src/paths.rs
@@ -1,203 +1,695 @@
-use crate::rayon::blocking_compute;
+use crate::{data::DIRTY_PATH, model::blocking_io, rayon::blocking_compute};
+use futures_util::io;
 use raphtory::{
+    db::api::{
+        storage::storage::{Config, Extension, PersistenceStrategy},
+        view::{internal::InternalStorageOps, MaterializedGraph},
+    },
     errors::{GraphError, InvalidPathReason},
-    serialise::{metadata::GraphMetadata, GraphFolder},
+    prelude::GraphViewOps,
+    serialise::{
+        metadata::GraphMetadata, GraphFolder, GraphPaths, RelativePath, StableDecode,
+        WriteableGraphFolder, ROOT_META_PATH,
+    },
 };
 use std::{
+    cmp::Ordering,
     fs,
+    fs::File,
+    io::{ErrorKind, Read, Seek, Write},
     ops::Deref,
-    path::{Component, Path, PathBuf},
+    panic::Location,
+    path::{Component, Path, PathBuf, StripPrefixError},
     time::{SystemTime, UNIX_EPOCH},
 };
+use tracing::{error, warn};
+use zip::ZipArchive;
 
-#[derive(Clone, Debug, PartialOrd, PartialEq, Ord, Eq)]
-pub struct ExistingGraphFolder {
-    folder: ValidGraphFolder,
+pub trait ValidGraphPaths {
+    fn local_path(&self) -> &str;
+
+    fn graph_folder(&self) -> &impl GraphPaths;
+
+    fn with_internal_errors<R: WithPath>(
+        &self,
+        fun: impl FnOnce() -> R,
+    ) -> Result<R::Value, PathValidationError> {
+        fun().with_path(self.local_path())
+    }
 }
 
-impl Deref for ExistingGraphFolder {
-    type Target = ValidGraphFolder;
+pub struct ValidPath(PathBuf);
 
-    fn deref(&self) -> &Self::Target {
-        &self.folder
+fn valid_path_inner(
+    base_path: PathBuf,
+    relative_path: &str,
+) -> Result<PathBuf, InternalPathValidationError> {
+    ensure_clean_folder(&base_path)?;
+    let mut full_path = base_path.clone();
+    let user_facing_path: &Path = relative_path.as_ref();
+
+    if relative_path.contains(r"//") {
+        Err(InvalidPathReason::DoubleForwardSlash)?;
+    }
+    if relative_path.contains(r"\") {
+        Err(InvalidPathReason::BackslashError)?;
+    }
+
+    // fail if any component is a Prefix (C://), tries to access root,
+    // tries to access a parent dir or is a symlink which could break out of the working dir
+    for component in user_facing_path.components() {
+        extend_and_validate(&mut full_path, component)?;
+    }
+
+    Ok(full_path)
+}
+
+impl ValidPath {
+    pub fn try_new(base_path: PathBuf, relative_path: &str) -> Result<Self, PathValidationError> {
+        let full_path = valid_path_inner(base_path, relative_path).with_path(relative_path)?;
+        Ok(ValidPath(full_path))
+    }
+    /// path exists and is a graph
+    pub fn is_graph(&self) -> bool {
+        self.0.exists() && self.0.join(ROOT_META_PATH).exists()
+    }
+
+    /// path exists and is a namespace
+    pub fn is_namespace(&self) -> bool {
+        self.0.exists() && !self.0.join(ROOT_META_PATH).exists()
+    }
+
+    pub fn into_path(self) -> PathBuf {
+        self.0
     }
 }
 
-impl From<ValidGraphFolder> for GraphFolder {
-    fn from(value: ValidGraphFolder) -> Self {
-        value.folder
+#[derive(Clone, Debug, PartialOrd, PartialEq, Ord, Eq)]
+pub struct ExistingGraphFolder(pub(crate) ValidGraphFolder);
+
+impl ValidGraphPaths for ExistingGraphFolder {
+    fn local_path(&self) -> &str {
+        self.0.local_path()
+    }
+
+    fn graph_folder(&self) -> &impl GraphPaths {
+        self.0.graph_folder()
     }
 }
 
-impl From<ExistingGraphFolder> for GraphFolder {
-    fn from(value: ExistingGraphFolder) -> Self {
-        value.folder.folder
+impl Deref for ExistingGraphFolder {
+    type Target = ValidGraphFolder;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
     }
 }
+
 impl ExistingGraphFolder {
-    pub(crate) fn try_from(base_path: PathBuf, relative_path: &str) -> Result<Self, GraphError> {
-        let graph_folder = ValidGraphFolder::try_from(base_path, relative_path)?;
-        if graph_folder.get_meta_path().exists() {
-            Ok(Self {
-                folder: graph_folder,
-            })
+    pub fn try_from(base_path: PathBuf, relative_path: &str) -> Result<Self, PathValidationError> {
+        let path = ValidPath::try_new(base_path, relative_path)?;
+        Self::try_from_valid(path, relative_path)
+    }
+
+    pub fn try_from_valid(
+        base_path: ValidPath,
+        relative_path: &str,
+    ) -> Result<Self, PathValidationError> {
+        let graph_folder: GraphFolder = base_path.into_path().into();
+        if graph_folder.is_reserved() {
+            Ok(Self(ValidGraphFolder {
+                global_path: graph_folder,
+                local_path: relative_path.to_string(),
+            }))
         } else {
-            Err(GraphError::GraphNotFound(graph_folder.to_error_path()))
+            Err(PathValidationError::GraphNotExistsError(
+                relative_path.to_string(),
+            ))
         }
     }
 
-    pub(crate) fn get_graph_name(&self) -> Result<String, GraphError> {
-        let path = &self.get_base_path();
-        let last_component: Component = path.components().last().ok_or_else(|| {
-            GraphError::from(InvalidPathReason::PathNotParsable(self.to_error_path()))
-        })?;
-        match last_component {
-            Component::Normal(value) => {
-                value
-                    .to_str()
-                    .map(|s| s.to_string())
-                    .ok_or(GraphError::from(InvalidPathReason::PathNotParsable(
-                        self.to_error_path(),
-                    )))
+    pub fn replace_graph_data(&self, graph: MaterializedGraph) -> Result<(), PathValidationError> {
+        self.with_internal_errors(|| {
+            if let Some(path) = graph.disk_storage_path() {
+                if path != self.global_path.graph_path()? {
+                    return Err(InternalPathValidationError::MismatchedGraphPath);
+                }
+                self.global_path.write_metadata(&graph)?;
+            } else {
+                self.global_path.data_path()?.replace_graph(graph)?;
             }
-            Component::Prefix(_)
-            | Component::RootDir
-            | Component::CurDir
-            | Component::ParentDir => Err(GraphError::from(InvalidPathReason::PathNotParsable(
-                self.to_error_path(),
-            ))),
-        }
+            Ok(())
+        })
     }
 }
 
 #[derive(Clone, Debug, PartialOrd, PartialEq, Ord, Eq)]
 pub struct ValidGraphFolder {
-    folder: GraphFolder,
-    original_path: String,
+    global_path: GraphFolder,
+    local_path: String,
 }
 
-impl From<ExistingGraphFolder> for ValidGraphFolder {
-    fn from(value: ExistingGraphFolder) -> Self {
-        value.folder
+fn valid_component(component: Component<'_>) -> Result<&str, InvalidPathReason> {
+    match component {
+        Component::Prefix(_) => Err(InvalidPathReason::RootNotAllowed),
+        Component::RootDir => Err(InvalidPathReason::RootNotAllowed),
+        Component::CurDir => Err(InvalidPathReason::CurDirNotAllowed),
+        Component::ParentDir => Err(InvalidPathReason::ParentDirNotAllowed),
+        Component::Normal(component) => {
+            let component_str = component
+                .to_str()
+                .ok_or(InvalidPathReason::PathNotParsable)?;
+            if component_str.starts_with(".") {
+                Err(InvalidPathReason::HiddenPathNotAllowed)
+            } else {
+                Ok(component_str)
+            }
+        }
     }
 }
 
-impl Deref for ValidGraphFolder {
-    type Target = GraphFolder;
+fn extend_and_validate(
+    full_path: &mut PathBuf,
+    component: Component,
+) -> Result<(), InternalPathValidationError> {
+    let component = valid_component(component)?;
+    // check if some intermediate path is already a graph
+    if full_path.join(ROOT_META_PATH).exists() {
+        return Err(InvalidPathReason::ParentIsGraph.into());
+    }
+    full_path.push(component);
+    //check for symlinks
+    if full_path.is_symlink() {
+        return Err(InvalidPathReason::SymlinkNotAllowed.into());
+    }
+    ensure_clean_folder(&full_path)?;
+    Ok(())
+}
 
-    fn deref(&self) -> &Self::Target {
-        &self.folder
+#[derive(Clone, Debug)]
+pub struct NewPath {
+    path: PathBuf,
+    cleanup: Option<CleanupPath>,
+}
+
+impl NewPath {
+    pub fn is_new(&self) -> bool {
+        self.cleanup.is_some()
     }
 }
 
-pub(crate) fn valid_path(
+impl PartialEq for NewPath {
+    fn eq(&self, other: &Self) -> bool {
+        self.path.eq(&other.path)
+    }
+}
+
+impl PartialOrd for NewPath {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        self.path.partial_cmp(&other.path)
+    }
+}
+
+pub(crate) fn create_valid_path(
     base_path: PathBuf,
     relative_path: &str,
-    namespace: bool,
-) -> Result<PathBuf, InvalidPathReason> {
+) -> Result<NewPath, InternalPathValidationError> {
+    ensure_clean_folder(&base_path)?;
     let user_facing_path = PathBuf::from(relative_path);
 
     if relative_path.contains(r"//") {
-        return Err(InvalidPathReason::DoubleForwardSlash(user_facing_path));
+        return Err(InvalidPathReason::DoubleForwardSlash.into());
     }
     if relative_path.contains(r"\") {
-        return Err(InvalidPathReason::BackslashError(user_facing_path));
+        return Err(InvalidPathReason::BackslashError.into());
     }
 
     let mut full_path = base_path.clone();
+    let mut cleanup_marker = None;
     // fail if any component is a Prefix (C://), tries to access root,
     // tries to access a parent dir or is a symlink which could break out of the working dir
     for component in user_facing_path.components() {
-        match component {
-            Component::Prefix(_) => {
-                return Err(InvalidPathReason::RootNotAllowed(user_facing_path))
-            }
-            Component::RootDir => return Err(InvalidPathReason::RootNotAllowed(user_facing_path)),
-            Component::CurDir => return Err(InvalidPathReason::CurDirNotAllowed(user_facing_path)),
-            Component::ParentDir => {
-                return Err(InvalidPathReason::ParentDirNotAllowed(user_facing_path))
-            }
-            Component::Normal(component) => {
-                let component = component
-                    .to_str()
-                    .ok_or_else(|| InvalidPathReason::PathNotParsable(user_facing_path.clone()))?;
-                if component.starts_with(".") {
-                    return Err(InvalidPathReason::HiddenPathNotAllowed(user_facing_path));
-                }
-                // check if some intermediate path is already a graph
-                if full_path.join(".raph").exists() {
-                    return Err(InvalidPathReason::ParentIsGraph(user_facing_path));
-                }
-                full_path.push(component);
-                //check if the path with the component is a graph
-                if namespace && full_path.join(".raph").exists() {
-                    return Err(InvalidPathReason::ParentIsGraph(user_facing_path));
+        match extend_and_validate(&mut full_path, component) {
+            Ok(_) => {
+                if !full_path.exists() {
+                    if cleanup_marker.is_none() {
+                        cleanup_marker = Some(CleanupPath {
+                            path: full_path.clone(),
+                            dirty_marker: mark_dirty(&full_path)?,
+                        });
+                        fs::create_dir(&full_path)?;
+                    }
                 }
-                //check for symlinks
-                if full_path.is_symlink() {
-                    return Err(InvalidPathReason::SymlinkNotAllowed(user_facing_path));
+            }
+            Err(error) => {
+                if let Some(created_path) = cleanup_marker {
+                    created_path.cleanup()?;
                 }
+                return Err(error.into());
             }
         }
     }
-    Ok(full_path)
+    Ok(NewPath {
+        path: full_path,
+        cleanup: cleanup_marker,
+    })
 }
 
-impl ValidGraphFolder {
-    pub(crate) fn try_from(
+#[derive(Debug, Clone)]
+struct CleanupPath {
+    path: PathBuf,
+    dirty_marker: PathBuf,
+}
+
+impl CleanupPath {
+    fn persist(&self) -> Result<(), InternalPathValidationError> {
+        fs::remove_file(&self.dirty_marker)?;
+        Ok(())
+    }
+
+    fn cleanup(&self) -> Result<(), InternalPathValidationError> {
+        fs::remove_dir_all(&self.path)?;
+        fs::remove_file(&self.dirty_marker)?;
+        Ok(())
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct ValidWriteableGraphFolder {
+    global_path: WriteableGraphFolder,
+    local_path: String,
+    dirty_marker: Option<CleanupPath>,
+}
+
+impl ValidGraphPaths for ValidWriteableGraphFolder {
+    fn local_path(&self) -> &str {
+        &self.local_path
+    }
+
+    fn graph_folder(&self) -> &impl GraphPaths {
+        &self.global_path
+    }
+}
+
+impl ValidWriteableGraphFolder {
+    fn new_inner(
+        valid_path: NewPath,
+        graph_name: &str,
+    ) -> Result<Self, InternalPathValidationError> {
+        let is_new = valid_path.is_new();
+        let graph_folder = GraphFolder::from(valid_path.path);
+        if !is_new {
+            if !graph_folder.is_reserved() {
+                return Err(InternalPathValidationError::GraphIsNamespace);
+            }
+        }
+        let data_path = graph_folder.init_swap()?;
+        Ok(Self {
+            global_path: data_path,
+            dirty_marker: valid_path.cleanup,
+            local_path: graph_name.to_string(),
+        })
+    }
+    fn new(valid_path: NewPath, graph_name: &str) -> Result<Self, PathValidationError> {
+        Self::new_inner(valid_path, graph_name).map_err(|error| {
+            PathValidationError::InternalError {
+                graph: graph_name.to_string(),
+                error,
+            }
+        })
+    }
+
+    pub(crate) fn try_new(
         base_path: PathBuf,
         relative_path: &str,
-    ) -> Result<Self, InvalidPathReason> {
-        let full_path = valid_path(base_path, relative_path, false)?;
-        Ok(Self {
-            original_path: relative_path.to_owned(),
-            folder: GraphFolder::from(full_path),
+    ) -> Result<Self, PathValidationError> {
+        let path = create_valid_path(base_path, relative_path).map_err(|error| {
+            PathValidationError::InternalError {
+                graph: relative_path.to_string(),
+                error,
+            }
+        })?;
+        if !path.cleanup.is_some() {
+            return Err(PathValidationError::GraphExistsError(
+                relative_path.to_string(),
+            ));
+        }
+        Self::new(path, relative_path)
+    }
+
+    pub(crate) fn try_existing_or_new(
+        base_path: PathBuf,
+        relative_path: &str,
+    ) -> Result<Self, PathValidationError> {
+        let path = create_valid_path(base_path, relative_path).with_path(relative_path)?;
+        Self::new(path, relative_path)
+    }
+
+    fn write_graph_data_inner(
+        &self,
+        graph: MaterializedGraph,
+        config: Config,
+    ) -> Result<(), InternalPathValidationError> {
+        if Extension::disk_storage_enabled() {
+            let graph_path = self.graph_folder().graph_path()?;
+            if graph
+                .disk_storage_path()
+                .is_some_and(|path| path == &graph_path)
+            {
+                self.global_path.write_metadata(&graph)?;
+            } else {
+                graph.materialize_at_with_config(self.graph_folder(), config)?;
+            }
+        } else {
+            self.global_path.data_path()?.replace_graph(graph)?;
+        }
+        Ok(())
+    }
+    pub fn write_graph_data(
+        &self,
+        graph: MaterializedGraph,
+        config: Config,
+    ) -> Result<(), PathValidationError> {
+        self.write_graph_data_inner(graph, config)
+            .with_path(self.local_path())
+    }
+
+    pub fn read_graph(&self, config: Config) -> Result<MaterializedGraph, PathValidationError> {
+        self.with_internal_errors(|| {
+            if self.graph_folder().read_metadata()?.is_diskgraph {
+                MaterializedGraph::load_with_config(self.graph_folder(), config)
+            } else {
+                MaterializedGraph::decode_with_config(self.graph_folder(), config)
+            }
         })
     }
 
-    pub fn created(&self) -> Result<i64, GraphError> {
-        fs::metadata(self.get_graph_path())?.created()?.to_millis()
+    pub fn write_graph_bytes<R: Read + Seek + Send + 'static>(
+        &self,
+        bytes: R,
+        config: Config,
+    ) -> Result<(), PathValidationError> {
+        self.with_internal_errors(|| {
+            if Extension::disk_storage_enabled() {
+                MaterializedGraph::decode_from_zip_at(
+                    ZipArchive::new(bytes)?,
+                    self.graph_folder(),
+                    config,
+                )?;
+            } else {
+                self.global_path.data_path()?.unzip_to_folder(bytes)?;
+            }
+            Ok::<(), GraphError>(())
+        })
     }
 
-    pub fn last_opened(&self) -> Result<i64, GraphError> {
-        fs::metadata(self.get_graph_path())?.accessed()?.to_millis()
+    /// Swap old and new data and delete the old graph
+    pub fn finish(self) -> Result<ValidGraphFolder, PathValidationError> {
+        let data_path = self.global_path.finish().with_path(&self.local_path)?;
+        if let Some(cleanup) = self.dirty_marker.as_ref() {
+            cleanup.persist().with_path(&self.local_path)?;
+        }
+        Ok(ValidGraphFolder {
+            global_path: data_path,
+            local_path: self.local_path,
+        })
     }
+}
 
-    pub fn last_updated(&self) -> Result<i64, GraphError> {
-        fs::metadata(self.get_graph_path())?.modified()?.to_millis()
+#[derive(thiserror::Error, Debug)]
+pub enum InternalPathValidationError {
+    #[error(transparent)]
+    InvalidPath(#[from] InvalidPathReason),
+    #[error(transparent)]
+    IOError(io::Error),
+    #[error("Graph path should not be nested: {0}")]
+    NestedPath(PathBuf),
+    #[error("Graph metadata file does not exist")]
+    MissingMetadataFile,
+    #[error("Reading path from metadata failed: {0}")]
+    InvalidMetadata(#[from] serde_json::Error),
+    #[error(transparent)]
+    GraphError(#[from] GraphError),
+    #[error("Graph path should always have a parent")]
+    MissingParent,
+    #[error(transparent)]
+    StripPrefix(#[from] StripPrefixError),
+    #[error("Expected a graph but found a namespace")]
+    GraphIsNamespace,
+    #[error("Expected a namespace but found a graph")]
+    NamespaceIsGraph,
+    #[error("The path provided contains non-UTF8 characters.")]
+    NonUTFCharacters,
+    #[error("Relative path from metadata is empty")]
+    EmptyRelativePath,
+    #[error("Relative path from metadata has more than one component")]
+    RelativePathMultipleComponents,
+    #[error("Mismatched graph paths when updating metadata")]
+    MismatchedGraphPath,
+}
+
+impl From<io::Error> for InternalPathValidationError {
+    #[track_caller]
+    fn from(value: io::Error) -> Self {
+        let location = Location::caller();
+        error!("Unexpected IO failure at {location}: {}", value);
+        InternalPathValidationError::IOError(value)
     }
+}
+
+#[derive(thiserror::Error, Debug)]
+pub enum PathValidationError {
+    #[error("Graph '{0}' already exists")]
+    GraphExistsError(String),
+    #[error("Graph '{0}' does not exist")]
+    GraphNotExistsError(String),
+    #[error("'{0}' does not exist as a namespace")]
+    NamespaceDoesNotExist(String),
+    #[error("Invalid path '{graph}': {reason}")]
+    InvalidPath {
+        graph: String,
+        reason: InvalidPathReason,
+    },
+    #[error("Graph '{graph}' is corrupted: {error}")]
+    InternalError {
+        graph: String,
+        error: InternalPathValidationError,
+    },
+    #[error("Unexpected IO error for graph '{graph}': {error}")]
+    IOError { graph: String, error: io::Error },
+}
+
+pub trait WithPath {
+    type Value;
+    fn with_path<S: Into<String>>(self, graph: S) -> Result<Self::Value, PathValidationError>;
+}
 
-    pub async fn created_async(&self) -> Result<i64, GraphError> {
-        let metadata = tokio::fs::metadata(self.get_graph_path()).await?;
-        metadata.created()?.to_millis()
+impl<V, E: Into<InternalPathValidationError>> WithPath for Result<V, E> {
+    type Value = V;
+    fn with_path<S: Into<String>>(self, graph: S) -> Result<V, PathValidationError> {
+        self.map_err(move |error| {
+            let error = error.into();
+            let graph = graph.into();
+            match error {
+                InternalPathValidationError::InvalidPath(reason) => {
+                    PathValidationError::InvalidPath { graph, reason }
+                }
+                _ => PathValidationError::InternalError { graph, error },
+            }
+        })
     }
+}
 
-    pub async fn last_opened_async(&self) -> Result<i64, GraphError> {
-        let metadata = tokio::fs::metadata(self.get_graph_path()).await?;
-        metadata.accessed()?.to_millis()
+fn valid_relative_path(relative_path: &Path) -> Result<(), InternalPathValidationError> {
+    let mut components = relative_path.components();
+    valid_component(
+        components
+            .next()
+            .ok_or(InternalPathValidationError::EmptyRelativePath)?,
+    )?;
+    if components.next().is_some() {
+        return Err(InternalPathValidationError::RelativePathMultipleComponents);
     }
+    Ok(())
+}
 
-    pub async fn last_updated_async(&self) -> Result<i64, GraphError> {
-        let metadata = tokio::fs::metadata(self.get_graph_path()).await?;
-        metadata.modified()?.to_millis()
+fn read_dirty_relative_path(
+    base_path: &Path,
+) -> Result<Option<String>, InternalPathValidationError> {
+    let mut file = match File::open(base_path.join(DIRTY_PATH)) {
+        Ok(file) => file,
+        Err(error) => {
+            return match error.kind() {
+                ErrorKind::NotFound => Ok(None),
+                _ => Err(error.into()),
+            }
+        }
+    };
+    let mut json_string = String::new();
+    file.read_to_string(&mut json_string)?;
+    let path: RelativePath = serde_json::from_str(&json_string)?;
+    valid_relative_path(path.path.as_ref())?;
+    Ok(Some(path.path))
+}
+
+pub(crate) fn ensure_clean_folder(base_path: &Path) -> Result<(), InternalPathValidationError> {
+    if base_path.is_dir() {
+        match read_dirty_relative_path(base_path) {
+            Ok(path) => {
+                if let Some(path) = path {
+                    let full_path = base_path.join(path);
+                    warn!("Found dirty path {}, cleaning...", full_path.display());
+                    fs::remove_dir_all(full_path)?;
+                }
+            }
+            Err(error) => {
+                warn!("Found dirty file with invalid path: {error}, cleaning...")
+            }
+        }
+        match fs::remove_file(base_path.join(DIRTY_PATH)) {
+            Ok(_) => {}
+            Err(err) => match err.kind() {
+                ErrorKind::NotFound => {}
+                _ => Err(err)?,
+            },
+        };
+    }
+    Ok(())
+}
+
+/// Mark path as dirty
+/// - ensure parent is clean
+/// - create dirty file and fsync it
+pub(crate) fn mark_dirty(path: &Path) -> Result<PathBuf, InternalPathValidationError> {
+    let cleanup_path = path
+        .file_name()
+        .ok_or(InternalPathValidationError::MissingParent)?
+        .to_str()
+        .ok_or(InternalPathValidationError::NonUTFCharacters)?
+        .to_string();
+    let parent = path
+        .parent()
+        .ok_or(InternalPathValidationError::MissingParent)?;
+    ensure_clean_folder(parent)?;
+    let dirty_file_path = parent.join(DIRTY_PATH);
+    let mut dirty_file = File::create_new(&dirty_file_path)?;
+    dirty_file.write_all(&serde_json::to_vec(&RelativePath { path: cleanup_path })?)?;
+    // make sure the dirty path is properly recorded before we proceed!
+    dirty_file.sync_all()?;
+    Ok(dirty_file_path)
+}
+
+impl GraphPaths for ValidGraphFolder {
+    fn root(&self) -> &Path {
+        self.global_path.root()
+    }
+
+    fn relative_data_path(&self) -> Result<String, GraphError> {
+        self.global_path.relative_data_path()
+    }
+
+    fn relative_graph_path(&self) -> Result<String, GraphError> {
+        self.global_path.relative_graph_path()
+    }
+}
+
+impl ValidGraphPaths for ValidGraphFolder {
+    fn local_path(&self) -> &str {
+        &self.local_path
     }
 
-    pub async fn read_metadata_async(&self) -> Result<GraphMetadata, GraphError> {
-        let folder = self.folder.clone();
-        blocking_compute(move || folder.read_metadata()).await
+    fn graph_folder(&self) -> &impl GraphPaths {
+        &self.global_path
     }
+}
 
-    pub fn get_original_path_str(&self) -> &str {
-        &self.original_path
+impl ValidGraphFolder {
+    fn with_internal_errors<V>(
+        &self,
+        map: impl FnOnce() -> Result<V, InternalPathValidationError>,
+    ) -> Result<V, PathValidationError> {
+        map().with_path(self.local_path())
     }
 
-    pub fn get_original_path(&self) -> &Path {
-        &Path::new(&self.original_path)
+    pub fn graph_folder(&self) -> &GraphFolder {
+        &self.global_path
+    }
+    pub fn created(&self) -> Result<i64, PathValidationError> {
+        self.with_internal_errors(|| {
+            Ok(self.root_meta_path().metadata()?.created()?.to_millis()?)
+        })
+    }
+
+    pub fn last_opened(&self) -> Result<i64, PathValidationError> {
+        self.with_internal_errors(|| {
+            Ok(fs::metadata(self.global_path.meta_path()?)?
+                .accessed()?
+                .to_millis()?)
+        })
+    }
+
+    pub fn last_updated(&self) -> Result<i64, PathValidationError> {
+        self.with_internal_errors(|| {
+            Ok(fs::metadata(self.meta_path()?)?.modified()?.to_millis()?)
+        })
+    }
+
+    pub async fn created_async(&self) -> Result<i64, PathValidationError> {
+        let cloned = self.clone();
+        blocking_io(move || cloned.created()).await
+    }
+
+    pub async fn last_opened_async(&self) -> Result<i64, PathValidationError> {
+        let cloned = self.clone();
+        blocking_io(move || cloned.last_opened()).await
+    }
+
+    pub async fn last_updated_async(&self) -> Result<i64, PathValidationError> {
+        let cloned = self.clone();
+        blocking_io(move || cloned.last_updated()).await
+    }
+
+    pub async fn read_metadata_async(&self) -> Result<GraphMetadata, PathValidationError> {
+        let folder: GraphFolder = self.global_path.clone();
+        blocking_compute(move || folder.read_metadata())
+            .await
+            .with_path(self.local_path())
     }
 
     /// This returns the PathBuf used to build multiple GraphError types
     pub fn to_error_path(&self) -> PathBuf {
-        self.original_path.to_owned().into()
+        self.local_path.to_owned().into()
+    }
+
+    pub fn get_graph_name(&self) -> Result<String, PathValidationError> {
+        let path: &Path = self.local_path.as_ref();
+        let name = self.with_internal_errors(|| {
+            let last_component: Component = path
+                .components()
+                .last()
+                .ok_or(InvalidPathReason::PathNotParsable)?;
+            match last_component {
+                Component::Normal(value) => Ok(value
+                    .to_str()
+                    .map(|s| s.to_string())
+                    .ok_or(InvalidPathReason::PathNotParsable)?),
+                Component::Prefix(_)
+                | Component::RootDir
+                | Component::CurDir
+                | Component::ParentDir => Err(InvalidPathReason::PathNotParsable)?,
+            }
+        })?;
+
+        Ok(name)
+    }
+    pub(crate) fn as_existing(&self) -> Result<ExistingGraphFolder, PathValidationError> {
+        if self.global_path.is_reserved() {
+            Ok(ExistingGraphFolder(self.clone()))
+        } else {
+            Err(PathValidationError::GraphNotExistsError(
+                self.local_path.clone(),
+            ))
+        }
     }
 }
 
diff --git a/raphtory-graphql/src/python/client/mod.rs b/raphtory-graphql/src/python/client/mod.rs
index cf3c78795d..fb24d292d5 100644
--- a/raphtory-graphql/src/python/client/mod.rs
+++ b/raphtory-graphql/src/python/client/mod.rs
@@ -1,13 +1,12 @@
-use minijinja::{Environment, Value};
+use crate::client::{inner_collection, ClientError};
 use pyo3::{exceptions::PyValueError, prelude::*, pyclass, pymethods};
-use raphtory::errors::GraphError;
 use raphtory_api::{
     core::{
         entities::{properties::prop::Prop, GID},
         storage::timeindex::EventTime,
         utils::time::IntoTime,
     },
-    python::timeindex::PyEventTime,
+    python::{error::adapt_err_value, timeindex::PyEventTime},
 };
 use serde::{ser::SerializeStruct, Serialize, Serializer};
 use serde_json::json;
@@ -232,108 +231,6 @@ impl PyEdgeAddition {
     }
 }
 
-fn inner_collection(value: &Prop) -> String {
-    match value {
-        Prop::Str(value) => format!("{{ str: \"{}\" }}", value),
-        Prop::U8(value) => format!("{{ u64: {} }}", value),
-        Prop::U16(value) => format!("{{ u64: {} }}", value),
-        Prop::I32(value) => format!("{{ i64: {} }}", value),
-        Prop::I64(value) => format!("{{ i64: {} }}", value),
-        Prop::U32(value) => format!("{{ u64: {} }}", value),
-        Prop::U64(value) => format!("{{ u64: {} }}", value),
-        Prop::F32(value) => format!("{{ f64: {} }}", value),
-        Prop::F64(value) => format!("{{ f64: {} }}", value),
-        Prop::Bool(value) => format!("{{ bool: {} }}", value),
-        Prop::List(value) => {
-            let vec: Vec<String> = value.iter().map(inner_collection).collect();
-            format!("{{ list: [{}] }}", vec.join(", "))
-        }
-        Prop::Array(value) => {
-            let vec: Vec<String> = value.iter_prop().map(|v| inner_collection(&v)).collect();
-            format!("{{ list: [{}] }}", vec.join(", "))
-        }
-        Prop::Map(value) => {
-            let properties_array: Vec<String> = value
-                .iter()
-                .map(|(k, v)| format!("{{ key: \"{}\", value: {} }}", k, inner_collection(v)))
-                .collect();
-            format!("{{ object: [{}] }}", properties_array.join(", "))
-        }
-        Prop::DTime(value) => format!("{{ str: \"{}\" }}", value),
-        Prop::NDTime(value) => format!("{{ str: \"{}\" }}", value),
-        Prop::Decimal(value) => format!("{{ decimal: {} }}", value),
-    }
-}
-
-fn to_graphql_valid(key: &String, value: &Prop) -> String {
-    match value {
-        Prop::Str(value) => format!("{{ key: \"{}\", value: {{ str: \"{}\" }} }}", key, value),
-        Prop::U8(value) => format!("{{ key: \"{}\", value: {{ u64: {} }} }}", key, value),
-        Prop::U16(value) => format!("{{ key: \"{}\", value: {{ u64: {} }} }}", key, value),
-        Prop::I32(value) => format!("{{ key: \"{}\", value: {{ i64: {} }} }}", key, value),
-        Prop::I64(value) => format!("{{ key: \"{}\", value: {{ i64: {} }} }}", key, value),
-        Prop::U32(value) => format!("{{ key: \"{}\", value: {{ u64: {} }} }}", key, value),
-        Prop::U64(value) => format!("{{ key: \"{}\", value: {{ u64: {} }} }}", key, value),
-        Prop::F32(value) => format!("{{ key: \"{}\", value: {{ f64: {} }} }}", key, value),
-        Prop::F64(value) => format!("{{ key: \"{}\", value: {{ f64: {} }} }}", key, value),
-        Prop::Bool(value) => format!("{{ key: \"{}\", value: {{ bool: {} }} }}", key, value),
-        Prop::List(value) => {
-            let vec: Vec<String> = value.iter().map(inner_collection).collect();
-            format!(
-                "{{ key: \"{}\", value: {{ list: [{}] }} }}",
-                key,
-                vec.join(", ")
-            )
-        }
-        Prop::Array(value) => {
-            let vec: Vec<String> = value.iter_prop().map(|v| inner_collection(&v)).collect();
-            format!(
-                "{{ key: \"{}\", value: {{ list: [{}] }} }}",
-                key,
-                vec.join(", ")
-            )
-        }
-        Prop::Map(value) => {
-            let properties_array: Vec<String> = value
-                .iter()
-                .map(|(k, v)| format!("{{ key: \"{}\", value: {} }}", k, inner_collection(v)))
-                .collect();
-            format!(
-                "{{ key: \"{}\", value: {{ object: [{}] }} }}",
-                key,
-                properties_array.join(", ")
-            )
-        }
-        Prop::DTime(value) => format!("{{ key: \"{}\", value: {{ str: \"{}\" }} }}", key, value),
-        Prop::NDTime(value) => format!("{{ key: \"{}\", value: {{ str: \"{}\" }} }}", key, value),
-        Prop::Decimal(value) => format!(
-            "{{ key: \"{}\", value: {{ decimal: \"{}\" }} }}",
-            key, value
-        ),
-    }
-}
-
-pub(crate) fn build_property_string(properties: HashMap<String, Prop>) -> String {
-    let properties_array: Vec<String> = properties
-        .iter()
-        .map(|(k, v)| to_graphql_valid(k, v))
-        .collect();
-
-    format!("[{}]", properties_array.join(", "))
-}
-
-pub(crate) fn build_query(template: &str, context: Value) -> Result<String, GraphError> {
-    let mut env = Environment::new();
-    env.add_template("template", template)
-        .map_err(|e| GraphError::JinjaError(e.to_string()))?;
-    let query = env
-        .get_template("template")
-        .map_err(|e| GraphError::JinjaError(e.to_string()))?
-        .render(context)
-        .map_err(|e| GraphError::JinjaError(e.to_string()))?;
-    Ok(query)
-}
-
 /// Specifies that **all** properties should be included when creating an index.
 /// Use one of the predefined variants: ALL , ALL_METADATA , or ALL_TEMPORAL .
 #[derive(Clone, Serialize, PartialEq)]
@@ -436,3 +333,10 @@ impl PyRemoteIndexSpec {
         }
     }
 }
+
+// Takes care of the ClientError -> PyException conversion
+impl From<ClientError> for PyErr {
+    fn from(err: ClientError) -> Self {
+        adapt_err_value(&err)
+    }
+}
diff --git a/raphtory-graphql/src/python/client/raphtory_client.rs b/raphtory-graphql/src/python/client/raphtory_client.rs
index 504ce1fbfc..10473242a2 100644
--- a/raphtory-graphql/src/python/client/raphtory_client.rs
+++ b/raphtory-graphql/src/python/client/raphtory_client.rs
@@ -1,24 +1,16 @@
 use crate::{
+    client::{is_online, raphtory_client::RaphtoryGraphQLClient, ClientError},
     python::{
         client::{remote_graph::PyRemoteGraph, PyRemoteIndexSpec},
-        encode_graph,
-        server::is_online,
-        translate_from_python, translate_map_to_python,
+        encode_graph, translate_from_python, translate_map_to_python,
     },
-    url_encode::url_decode_graph,
 };
-use pyo3::{
-    exceptions::{PyException, PyValueError},
-    prelude::*,
-    types::PyDict,
-};
-use raphtory::{db::api::view::MaterializedGraph, serialise::GraphFolder};
-use raphtory_api::python::error::adapt_err_value;
-use reqwest::{multipart, multipart::Part, Client};
-use serde_json::{json, Value as JsonValue};
-use std::{collections::HashMap, future::Future, io::Cursor, sync::Arc};
-use tokio::runtime::Runtime;
+use pyo3::{exceptions::PyException, prelude::*, types::PyDict};
+use raphtory::{db::api::view::MaterializedGraph, python::utils::execute_async_task};
+use serde_json::Value as JsonValue;
+use std::{collections::HashMap, future::Future, sync::Arc};
 use tracing::debug;
+use url::Url;
 
 /// A client for handling GraphQL operations in the context of Raphtory.
 ///
@@ -28,95 +20,29 @@ use tracing::debug;
 #[derive(Clone)]
 #[pyclass(name = "RaphtoryClient", module = "raphtory.graphql")]
 pub struct PyRaphtoryClient {
-    pub(crate) url: String,
-    pub(crate) token: String,
-    client: Client,
-    runtime: Arc<Runtime>,
+    pub(crate) client: RaphtoryGraphQLClient,
 }
 
 impl PyRaphtoryClient {
-    pub(crate) fn query_with_json_variables(
-        &self,
-        query: String,
-        variables: HashMap<String, JsonValue>,
-    ) -> PyResult<HashMap<String, JsonValue>> {
-        let client = self.clone();
-        let (graphql_query, mut graphql_result) = self.execute_async_task(move || async move {
-            client.send_graphql_query(query, variables).await
-        })?;
-
-        match graphql_result.remove("errors") {
-            None => {}
-            Some(errors) => {
-                let exception = match errors {
-                    JsonValue::Array(errors) => {
-                        let formatted_errors = errors
-                            .iter()
-                            .map(|err| format!("{}", err))
-                            .collect::<Vec<_>>()
-                            .join("\n\t");
-
-                        PyException::new_err(format!(
-                            "After sending query to the server:\n\t{}\nGot the following errors:\n\t{}",
-                            graphql_query.to_string(),
-                            formatted_errors
-                        ))
-                    }
-                    _ => PyException::new_err(format!(
-                        "Error while reading server response for query:\n\t{graphql_query}"
-                    )),
-                };
-                return Err(exception);
-            }
-        }
-        match graphql_result.remove("data") {
-            Some(JsonValue::Object(data)) => Ok(data.into_iter().collect()),
-            _ => Err(PyException::new_err(format!(
-                "Error while reading server response for query:\n\t{graphql_query}"
-            ))),
-        }
+    /// Run an async operation that returns Result<O, ClientError> and map errors to PyErr.
+    pub(crate) fn run_async<F, Fut, O>(&self, f: F) -> PyResult<O>
+    where
+        F: FnOnce(RaphtoryGraphQLClient) -> Fut + Send + 'static,
+        Fut: Future<Output = Result<O, ClientError>> + Send + 'static,
+        O: Send + 'static,
+    {
+        let client = self.client.clone();
+        let fut = f(client);
+        let result = execute_async_task(|| fut);
+        result.map_err(PyErr::from)
     }
 
-    /// Returns the query sent and the response.
-    ///
-    /// Arguments:
-    ///     query (str):
-    ///     variables (tuple(string, JsonValue)):
-    ///
-    /// Returns:
-    ///     PyResult:
-    async fn send_graphql_query(
+    pub(crate) fn query_with_json_variables(
         &self,
         query: String,
         variables: HashMap<String, JsonValue>,
-    ) -> PyResult<(JsonValue, HashMap<String, JsonValue>)> {
-        let request_body = json!({
-            "query": query,
-            "variables": variables
-        });
-
-        let response = self
-            .client
-            .post(&self.url)
-            .bearer_auth(&self.token)
-            .json(&request_body)
-            .send()
-            .await
-            .map_err(|err| adapt_err_value(&err))?;
-
-        response
-            .json()
-            .await
-            .map_err(|err| adapt_err_value(&err))
-            .map(|json| (request_body, json))
-    }
-    pub fn execute_async_task<T, F, O>(&self, task: T) -> O
-    where
-        T: FnOnce() -> F + Send + 'static,
-        F: Future<Output = O> + 'static,
-        O: Send + 'static,
-    {
-        Python::with_gil(|py| py.allow_threads(|| self.runtime.block_on(task())))
+    ) -> PyResult<HashMap<String, JsonValue>> {
+        self.run_async(move |client| async move { client.query(&query, variables).await })
     }
 }
 
@@ -125,38 +51,10 @@ impl PyRaphtoryClient {
     #[new]
     #[pyo3(signature = (url, token=None))]
     pub(crate) fn new(url: String, token: Option<String>) -> PyResult<Self> {
-        let token = token.unwrap_or("".to_owned());
-        match reqwest::blocking::Client::new()
-            .get(&url)
-            .bearer_auth(&token)
-            .send()
-        {
-            Ok(response) => {
-                if response.status() == 200 {
-                    let client = Client::new();
-                    let runtime = Arc::new(
-                        tokio::runtime::Builder::new_multi_thread()
-                            .enable_all()
-                            .build()?,
-                    );
-                    Ok(Self {
-                        url,
-                        token,
-                        client,
-                        runtime,
-                    })
-                } else {
-                    Err(PyValueError::new_err(format!(
-                        "Could not connect to the given server - response {}",
-                        response.status()
-                    )))
-                }
-            }
-            Err(e) => Err(PyValueError::new_err(format!(
-                "Could not connect to the given server - no response --{}",
-                e.to_string()
-            ))),
-        }
+        let url = Url::parse(url.as_str()).map_err(|e| PyException::new_err(e.to_string()))?;
+        let client = execute_async_task(|| RaphtoryGraphQLClient::connect(url, token))
+            .map_err(PyErr::from)?;
+        Ok(Self { client })
     }
 
     /// Check if the server is online.
@@ -164,7 +62,7 @@ impl PyRaphtoryClient {
     /// Returns:
     ///     bool: Returns true if server is online otherwise false.
     fn is_server_online(&self) -> bool {
-        is_online(&self.url)
+        is_online(self.client.url.as_ref())
     }
 
     /// Make a GraphQL query against the server.
@@ -188,7 +86,7 @@ impl PyRaphtoryClient {
             let json_value = translate_from_python(value)?;
             json_variables.insert(key, json_value);
         }
-        let data = py.allow_threads(|| self.query_with_json_variables(query, json_variables))?;
+        let data = py.detach(|| self.query_with_json_variables(query, json_variables))?;
         translate_map_to_python(py, data)
     }
 
@@ -204,31 +102,14 @@ impl PyRaphtoryClient {
     #[pyo3(signature = (path, graph, overwrite = false))]
     fn send_graph(&self, path: String, graph: MaterializedGraph, overwrite: bool) -> PyResult<()> {
         let encoded_graph = encode_graph(graph)?;
-
-        let query = r#"
-            mutation SendGraph($path: String!, $graph: String!, $overwrite: Boolean!) {
-                sendGraph(path: $path, graph: $graph, overwrite: $overwrite)
-            }
-        "#
-        .to_owned();
-        let variables = [
-            ("path".to_owned(), json!(path)),
-            ("graph".to_owned(), json!(encoded_graph)),
-            ("overwrite".to_owned(), json!(overwrite)),
-        ];
-
-        let data = self.query_with_json_variables(query, variables.into())?;
-
-        match data.get("sendGraph") {
-            Some(JsonValue::String(name)) => {
-                debug!("Sent graph '{name}' to the server");
-                Ok(())
-            }
-            _ => Err(PyException::new_err(format!(
-                "Error Sending Graph. Got response {:?}",
-                data
-            ))),
-        }
+        let path_clone = path.clone();
+        self.run_async(move |client| async move {
+            client
+                .send_graph(&path_clone, &encoded_graph, overwrite)
+                .await
+        })?;
+        debug!("Sent graph '{path}' to the server");
+        Ok(())
     }
 
     /// Upload graph file from a path file_path on the client
@@ -242,71 +123,8 @@ impl PyRaphtoryClient {
     ///     dict[str, Any]: The data field from the graphQL response after executing the mutation.
     #[pyo3(signature = (path, file_path, overwrite = false))]
     fn upload_graph(&self, path: String, file_path: String, overwrite: bool) -> PyResult<()> {
-        let remote_client = self.clone();
-        let client = self.client.clone();
-        self.execute_async_task(move || async move {
-            let folder = GraphFolder::from(file_path.clone());
-            let mut buffer = Vec::new();
-            folder.create_zip(Cursor::new(&mut buffer))?;
-
-
-            let variables = format!(
-                r#""path": "{}", "overwrite": {}, "graph": null"#,
-                path, overwrite
-            );
-
-            let operations = format!(
-                r#"{{
-            "query": "mutation UploadGraph($path: String!, $graph: Upload!, $overwrite: Boolean!) {{ uploadGraph(path: $path, graph: $graph, overwrite: $overwrite) }}",
-            "variables": {{ {} }}
-        }}"#,
-                variables
-            );
-
-            let form = multipart::Form::new()
-                .text("operations", operations)
-                .text("map", r#"{"0": ["variables.graph"]}"#)
-                .part("0", Part::bytes(buffer).file_name(file_path.clone()));
-
-            let response = client
-                .post(&remote_client.url)
-                .bearer_auth(&remote_client.token)
-                .multipart(form)
-                .send()
-                .await
-                .map_err(|err| adapt_err_value(&err))?;
-
-            let status = response.status();
-            let text = response.text().await.map_err(|err| adapt_err_value(&err))?;
-
-            if !status.is_success() {
-                return Err(PyException::new_err(format!(
-                    "Error Uploading Graph. Status: {}. Response: {}",
-                    status, text
-                )));
-            }
-
-            let mut data: HashMap<String, JsonValue> =
-                serde_json::from_str(&text).map_err(|err| {
-                    PyException::new_err(format!(
-                        "Failed to parse JSON response: {}. Response text: {}",
-                        err, text
-                    ))
-                })?;
-
-            match data.remove("data") {
-                Some(JsonValue::Object(_)) => Ok(()),
-                _ => match data.remove("errors") {
-                    Some(JsonValue::Array(errors)) => Err(PyException::new_err(format!(
-                        "Error Uploading Graph. Got errors:\n\t{:#?}",
-                        errors
-                    ))),
-                    _ => Err(PyException::new_err(format!(
-                        "Error Uploading Graph. Unexpected response: {}",
-                        text
-                    ))),
-                },
-            }
+        self.run_async(move |client| async move {
+            client.upload_graph(&path, &file_path, overwrite).await
         })
     }
 
@@ -320,28 +138,7 @@ impl PyRaphtoryClient {
     ///     None:
     #[pyo3(signature = (path, new_path))]
     fn copy_graph(&self, path: String, new_path: String) -> PyResult<()> {
-        let query = r#"
-            mutation CopyGraph($path: String!, $newPath: String!) {
-              copyGraph(
-                path: $path,
-                newPath: $newPath,
-              )
-            }"#
-        .to_owned();
-
-        let variables = [
-            ("path".to_owned(), json!(path)),
-            ("newPath".to_owned(), json!(new_path)),
-        ];
-
-        let data = self.query_with_json_variables(query.clone(), variables.into())?;
-        match data.get("copyGraph") {
-            Some(JsonValue::Bool(res)) => Ok((*res).clone()),
-            _ => Err(PyException::new_err(format!(
-                "Error while reading server response for query:\n\t{query}\nGot data:\n\t'{data:?}'"
-            ))),
-        }?;
-        Ok(())
+        self.run_async(move |client| async move { client.copy_graph(&path, &new_path).await })
     }
 
     /// Move graph from a path path on the server to a new_path on the server
@@ -354,28 +151,7 @@ impl PyRaphtoryClient {
     ///     None:
     #[pyo3(signature = (path, new_path))]
     fn move_graph(&self, path: String, new_path: String) -> PyResult<()> {
-        let query = r#"
-            mutation MoveGraph($path: String!, $newPath: String!) {
-              moveGraph(
-                path: $path,
-                newPath: $newPath,
-              )
-            }"#
-        .to_owned();
-
-        let variables = [
-            ("path".to_owned(), json!(path)),
-            ("newPath".to_owned(), json!(new_path)),
-        ];
-
-        let data = self.query_with_json_variables(query.clone(), variables.into())?;
-        match data.get("moveGraph") {
-            Some(JsonValue::Bool(res)) => Ok((*res).clone()),
-            _ => Err(PyException::new_err(format!(
-                "Error while reading server response for query:\n\t{query}\nGot data:\n\t'{data:?}'"
-            ))),
-        }?;
-        Ok(())
+        self.run_async(move |client| async move { client.move_graph(&path, &new_path).await })
     }
 
     /// Delete graph from a path path on the server
@@ -387,30 +163,13 @@ impl PyRaphtoryClient {
     ///     None:
     #[pyo3(signature = (path))]
     fn delete_graph(&self, path: String) -> PyResult<()> {
-        let query = r#"
-            mutation DeleteGraph($path: String!) {
-              deleteGraph(
-                path: $path,
-              )
-            }"#
-        .to_owned();
-
-        let variables = [("path".to_owned(), json!(path))];
-
-        let data = self.query_with_json_variables(query.clone(), variables.into())?;
-        match data.get("deleteGraph") {
-            Some(JsonValue::Bool(res)) => Ok((*res).clone()),
-            _ => Err(PyException::new_err(format!(
-                "Error while reading server response for query:\n\t{query}\nGot data:\n\t'{data:?}'"
-            ))),
-        }?;
-        Ok(())
+        self.run_async(move |client| async move { client.delete_graph(&path).await })
     }
 
     /// Receive graph from a path path on the server
     ///
     /// Note:
-    /// This downloads a copy of the graph. Modifications are not persistet to the server.
+    /// This downloads a copy of the graph. Modifications are not persisted to the server.
     ///
     /// Arguments:
     ///     path (str): the path of the graph to be received
@@ -418,22 +177,7 @@ impl PyRaphtoryClient {
     /// Returns:
     ///     Union[Graph, PersistentGraph]: A copy of the graph
     fn receive_graph(&self, path: String) -> PyResult<MaterializedGraph> {
-        let query = r#"
-            query ReceiveGraph($path: String!) {
-                receiveGraph(path: $path)
-            }"#
-        .to_owned();
-        let variables = [("path".to_owned(), json!(path))];
-        let data = self.query_with_json_variables(query.clone(), variables.into())?;
-        match data.get("receiveGraph") {
-            Some(JsonValue::String(graph)) => {
-                let mat_graph = url_decode_graph(graph)?;
-                Ok(mat_graph)
-            }
-            _ => Err(PyException::new_err(format!(
-                "Error while reading server response for query:\n\t{query}\nGot data:\n\t'{data:?}'"
-            ))),
-        }
+        self.run_async(move |client| async move { client.receive_graph_decoded(&path).await })
     }
 
     /// Create a new empty Graph on the server at path
@@ -446,26 +190,7 @@ impl PyRaphtoryClient {
     ///     None:
     ///
     fn new_graph(&self, path: String, graph_type: String) -> PyResult<()> {
-        let query = r#"
-            mutation NewGraph($path: String!) {
-              newGraph(
-                path: $path,
-                graphType: EVENT
-              )
-            }"#
-        .to_owned();
-        let query = query.replace("EVENT", &*graph_type);
-
-        let variables = [("path".to_owned(), json!(path))];
-
-        let data = self.query_with_json_variables(query.clone(), variables.into())?;
-        match data.get("newGraph") {
-            Some(JsonValue::Bool(res)) => Ok((*res).clone()),
-            _ => Err(PyException::new_err(format!(
-                "Error while reading server response for query:\n\t{query}\nGot data:\n\t'{data:?}'"
-            ))),
-        }?;
-        Ok(())
+        self.run_async(move |client| async move { client.new_graph(&path, &graph_type).await })
     }
 
     /// Get a RemoteGraph reference to a graph on the server at path
@@ -478,17 +203,16 @@ impl PyRaphtoryClient {
     ///
     fn remote_graph(&self, path: String) -> PyRemoteGraph {
         PyRemoteGraph {
-            path,
-            client: self.clone(),
+            graph: Arc::new(self.client.remote_graph(path)),
         }
     }
 
     /// Create Index for graph on the server at 'path'
     ///
     /// Arguments:
-    ///     path: the path of the graph to be created
-    ///     RemoteIndexSpec (RemoteIndexSpec): spec specifying the properties that need to be indexed
-    ///     in_ram (bool): create index in ram
+    ///     path (str): the path of the graph to be created
+    ///     index_spec (RemoteIndexSpec): spec specifying the properties that need to be indexed
+    ///     in_ram (bool): create index in ram. Defaults to True.
     ///
     /// Returns:
     ///     None:
@@ -500,28 +224,10 @@ impl PyRaphtoryClient {
         index_spec: PyRemoteIndexSpec,
         in_ram: bool,
     ) -> PyResult<()> {
-        let query = r#"
-            mutation CreateIndex($path: String!, $indexSpec: IndexSpecInput!, $inRam: Boolean!) {
-                createIndex(path: $path, indexSpec: $indexSpec, inRam: $inRam)
-            }
-        "#
-        .to_owned();
-
-        let variables = [
-            ("path".to_string(), json!(path)),
-            ("indexSpec".to_string(), json!(index_spec)),
-            ("inRam".to_string(), json!(in_ram)),
-        ]
-        .into_iter()
-        .collect();
-
-        let data = self.query_with_json_variables(query, variables)?;
-
-        match data.get("createIndex") {
-            Some(JsonValue::Bool(true)) => Ok(()),
-            _ => Err(PyException::new_err(format!(
-                "Failed to create index, server returned: {data:?}"
-            ))),
-        }
+        let spec_value =
+            serde_json::to_value(&index_spec).map_err(|e| PyException::new_err(e.to_string()))?;
+        self.run_async(
+            move |client| async move { client.create_index(&path, spec_value, in_ram).await },
+        )
     }
 }
diff --git a/raphtory-graphql/src/python/client/remote_edge.rs b/raphtory-graphql/src/python/client/remote_edge.rs
index 5b82b52e57..0101d3e5da 100644
--- a/raphtory-graphql/src/python/client/remote_edge.rs
+++ b/raphtory-graphql/src/python/client/remote_edge.rs
@@ -1,15 +1,8 @@
-use crate::python::client::{
-    build_property_string, build_query, raphtory_client::PyRaphtoryClient,
-};
-use minijinja::context;
-use pyo3::{pyclass, pymethods, Python};
-use raphtory::errors::GraphError;
-use raphtory_api::core::{
-    entities::properties::prop::Prop,
-    storage::timeindex::{AsTime, EventTime},
-    utils::time::IntoTime,
-};
-use std::collections::HashMap;
+use crate::client::{remote_edge::GraphQLRemoteEdge, ClientError};
+use pyo3::{pyclass, pymethods};
+use raphtory::python::utils::execute_async_task;
+use raphtory_api::core::{entities::properties::prop::Prop, storage::timeindex::EventTime};
+use std::{collections::HashMap, sync::Arc};
 
 /// A remote edge reference
 ///
@@ -19,22 +12,17 @@ use std::collections::HashMap;
 #[derive(Clone)]
 #[pyclass(name = "RemoteEdge", module = "raphtory.graphql")]
 pub struct PyRemoteEdge {
-    pub(crate) path: String,
-    pub(crate) client: PyRaphtoryClient,
-    pub(crate) src: String,
-    pub(crate) dst: String,
+    pub(crate) edge: Arc<GraphQLRemoteEdge>,
 }
 
 impl PyRemoteEdge {
-    pub(crate) fn new(path: String, client: PyRaphtoryClient, src: String, dst: String) -> Self {
+    pub(crate) fn new(edge: GraphQLRemoteEdge) -> Self {
         PyRemoteEdge {
-            path,
-            client,
-            src,
-            dst,
+            edge: Arc::new(edge),
         }
     }
 }
+
 #[pymethods]
 impl PyRemoteEdge {
     /// Add updates to an edge in the remote graph at a specified time.
@@ -52,32 +40,15 @@ impl PyRemoteEdge {
     #[pyo3(signature = (t, properties=None, layer=None))]
     fn add_updates(
         &self,
-        py: Python,
         t: EventTime,
         properties: Option<HashMap<String, Prop>>,
         layer: Option<&str>,
-    ) -> Result<(), GraphError> {
-        let template = r#"
-            {
-              updateGraph(path: "{{path}}") {
-                edge(src: "{{src}}",dst: "{{dst}}") {
-                  addUpdates(time: {{t}} {% if properties is not none %}, properties: {{ properties | safe }} {% endif %} {% if layer is not none %}, layer:  "{{layer}}" {% endif %})
-                }
-              }
-            }
-        "#;
-
-        let query_context = context! {
-            path => self.path,
-            src => self.src,
-            dst => self.dst,
-            t => t.into_time().t(),
-            properties =>  properties.map(|p| build_property_string(p)),
-            layer => layer
-        };
+    ) -> Result<(), ClientError> {
+        let edge = Arc::clone(&self.edge);
+        let layer_str = layer.map(|s| s.to_string());
 
-        let query = build_query(template, query_context)?;
-        let _ = &self.client.query(py, query, None)?;
+        let task = move || async move { edge.add_updates(t, properties, layer_str).await };
+        execute_async_task(task)?;
 
         Ok(())
     }
@@ -94,27 +65,12 @@ impl PyRemoteEdge {
     /// Raises:
     ///   GraphError: If the operation fails.
     #[pyo3(signature = (t, layer=None))]
-    fn delete(&self, py: Python, t: EventTime, layer: Option<&str>) -> Result<(), GraphError> {
-        let template = r#"
-            {
-              updateGraph(path: "{{path}}") {
-                edge(src: "{{src}}",dst: "{{dst}}") {
-                  delete(time: {{t}}, {% if layer is not none %}, layer:  "{{layer}}" {% endif %})
-                }
-              }
-            }
-        "#;
-
-        let query_context = context! {
-            path => self.path,
-            src => self.src,
-            dst => self.dst,
-            t => t.into_time().t(),
-            layer => layer
-        };
+    fn delete(&self, t: EventTime, layer: Option<&str>) -> Result<(), ClientError> {
+        let edge = Arc::clone(&self.edge);
+        let layer_str = layer.map(|s| s.to_string());
 
-        let query = build_query(template, query_context)?;
-        let _ = &self.client.query(py, query, None)?;
+        let task = move || async move { edge.delete(t, layer_str).await };
+        execute_async_task(task)?;
 
         Ok(())
     }
@@ -132,30 +88,14 @@ impl PyRemoteEdge {
     #[pyo3(signature = (properties, layer=None))]
     fn add_metadata(
         &self,
-        py: Python,
         properties: HashMap<String, Prop>,
         layer: Option<&str>,
-    ) -> Result<(), GraphError> {
-        let template = r#"
-            {
-              updateGraph(path: "{{path}}") {
-                edge(src: "{{src}}",dst: "{{dst}}") {
-                  addMetadata(properties:  {{ properties | safe }} {% if layer is not none %}, layer:  "{{layer}}" {% endif %})
-                }
-              }
-            }
-        "#;
+    ) -> Result<(), ClientError> {
+        let edge = Arc::clone(&self.edge);
+        let layer_str = layer.map(|s| s.to_string());
 
-        let query_context = context! {
-            path => self.path,
-            src => self.src,
-            dst => self.dst,
-            properties =>  build_property_string(properties),
-            layer => layer
-        };
-
-        let query = build_query(template, query_context)?;
-        let _ = &self.client.query(py, query, None)?;
+        let task = move || async move { edge.add_metadata(properties, layer_str).await };
+        execute_async_task(task)?;
 
         Ok(())
     }
@@ -173,30 +113,14 @@ impl PyRemoteEdge {
     #[pyo3(signature = (properties, layer=None))]
     pub fn update_metadata(
         &self,
-        py: Python,
         properties: HashMap<String, Prop>,
         layer: Option<&str>,
-    ) -> Result<(), GraphError> {
-        let template = r#"
-            {
-              updateGraph(path: "{{path}}") {
-                edge(src: "{{src}}",dst: "{{dst}}") {
-                  updateMetadata(properties:  {{ properties | safe }} {% if layer is not none %}, layer:  "{{layer}}" {% endif %})
-                }
-              }
-            }
-        "#;
-
-        let query_context = context! {
-            path => self.path,
-            src => self.src,
-            dst => self.dst,
-            properties =>  build_property_string(properties),
-            layer => layer
-        };
+    ) -> Result<(), ClientError> {
+        let edge = Arc::clone(&self.edge);
+        let layer_str = layer.map(|s| s.to_string());
 
-        let query = build_query(template, query_context)?;
-        let _ = &self.client.query(py, query, None)?;
+        let task = move || async move { edge.update_metadata(properties, layer_str).await };
+        execute_async_task(task)?;
 
         Ok(())
     }
diff --git a/raphtory-graphql/src/python/client/remote_graph.rs b/raphtory-graphql/src/python/client/remote_graph.rs
index cc7f19cc3b..98a645514a 100644
--- a/raphtory-graphql/src/python/client/remote_graph.rs
+++ b/raphtory-graphql/src/python/client/remote_graph.rs
@@ -1,22 +1,27 @@
-use crate::python::client::{
-    build_property_string, build_query, raphtory_client::PyRaphtoryClient,
-    remote_edge::PyRemoteEdge, remote_node::PyRemoteNode, PyEdgeAddition, PyNodeAddition,
+use crate::{
+    client::{
+        remote_edge::GraphQLRemoteEdge,
+        remote_graph::{build_query, GraphQLRemoteGraph},
+        remote_node::GraphQLRemoteNode,
+        ClientError,
+    },
+    python::client::{
+        remote_edge::PyRemoteEdge, remote_node::PyRemoteNode, PyEdgeAddition, PyNodeAddition,
+    },
 };
 use minijinja::context;
-use pyo3::{pyclass, pymethods, Python};
-use raphtory::errors::GraphError;
+use pyo3::{pyclass, pymethods};
+use raphtory::python::utils::execute_async_task;
 use raphtory_api::core::{
     entities::{properties::prop::Prop, GID},
-    storage::timeindex::{AsTime, EventTime},
-    utils::time::IntoTime,
+    storage::timeindex::EventTime,
 };
-use std::collections::HashMap;
+use std::{collections::HashMap, sync::Arc};
 
 #[derive(Clone)]
 #[pyclass(name = "RemoteGraph", module = "raphtory.graphql")]
 pub struct PyRemoteGraph {
-    pub(crate) path: String,
-    pub(crate) client: PyRaphtoryClient,
+    pub(crate) graph: Arc<GraphQLRemoteGraph>,
 }
 
 #[pymethods]
@@ -29,7 +34,12 @@ impl PyRemoteGraph {
     /// Returns:
     ///     RemoteNode: the remote node reference
     pub fn node(&self, id: GID) -> PyRemoteNode {
-        PyRemoteNode::new(self.path.clone(), self.client.clone(), id.to_string())
+        let node = GraphQLRemoteNode::new(
+            self.graph.path.clone(),
+            self.graph.client.clone(),
+            id.to_string(),
+        );
+        PyRemoteNode::new(node)
     }
 
     /// Gets a remote edge with the specified source and destination nodes
@@ -42,12 +52,13 @@ impl PyRemoteGraph {
     ///     RemoteEdge: the remote edge reference
     #[pyo3(signature = (src, dst))]
     pub fn edge(&self, src: GID, dst: GID) -> PyRemoteEdge {
-        PyRemoteEdge::new(
-            self.path.clone(),
-            self.client.clone(),
+        let edge = GraphQLRemoteEdge::new(
+            self.graph.path.clone(),
+            self.graph.client.clone(),
             src.to_string(),
             dst.to_string(),
-        )
+        );
+        PyRemoteEdge::new(edge)
     }
 
     /// Batch add node updates to the remote graph
@@ -58,7 +69,7 @@ impl PyRemoteGraph {
     /// Returns:
     ///     None:
     #[pyo3(signature = (updates))]
-    pub fn add_nodes(&self, py: Python, updates: Vec<PyNodeAddition>) -> Result<(), GraphError> {
+    pub fn add_nodes(&self, updates: Vec<PyNodeAddition>) -> Result<(), ClientError> {
         let template = r#"
         {
         updateGraph(path: "{{ path }}") {
@@ -110,16 +121,22 @@ impl PyRemoteGraph {
         "#;
 
         let query_context = context! {
-            path => self.path,
+            path => self.graph.path.clone(),
             nodes => updates
         };
 
         let query = build_query(template, query_context)?;
-        let _ = &self.client.query(py, query, None)?;
+        let task = {
+            let graph = Arc::clone(&self.graph);
+            move || async move { graph.client.query(&query, HashMap::new()).await }
+        };
+        execute_async_task(task)?;
 
         Ok(())
     }
 
+    // TODO: Still need to move add_nodes and add_edges logic over to Rust client in src/client/raphtory_client.rs
+
     /// Batch add edge updates to the remote graph
     ///
     /// Arguments:
@@ -128,7 +145,7 @@ impl PyRemoteGraph {
     /// Returns:
     ///     None:
     #[pyo3(signature = (updates))]
-    pub fn add_edges(&self, py: Python, updates: Vec<PyEdgeAddition>) -> Result<(), GraphError> {
+    pub fn add_edges(&self, updates: Vec<PyEdgeAddition>) -> Result<(), ClientError> {
         let template = r#"
                 {
                 updateGraph(path: "{{ path }}") {
@@ -181,12 +198,16 @@ impl PyRemoteGraph {
         "#;
 
         let query_context = context! {
-            path => self.path,
+            path => self.graph.path.clone(),
             edges => updates,
         };
 
         let query = build_query(template, query_context)?;
-        let _ = &self.client.query(py, query, None)?;
+        let task = {
+            let graph = Arc::clone(&self.graph);
+            move || async move { graph.client.query(&query, HashMap::new()).await }
+        };
+        execute_async_task(task)?;
 
         Ok(())
     }
@@ -204,38 +225,19 @@ impl PyRemoteGraph {
     #[pyo3(signature = (timestamp, id, properties = None, node_type = None))]
     pub fn add_node(
         &self,
-        py: Python,
         timestamp: EventTime,
         id: GID,
         properties: Option<HashMap<String, Prop>>,
         node_type: Option<&str>,
-    ) -> Result<PyRemoteNode, GraphError> {
-        let template = r#"
-        {
-            updateGraph(path: "{{ path }}") {
-                addNode(time: {{ time }}, name: "{{ name }}" {% if properties is not none %}, properties:  {{ properties | safe }} {% endif %}{% if node_type is not none %}, nodeType: "{{ node_type }}"{% endif %}) {
-                    success
-                }
-            }
-        }
-        "#;
-
-        let query_context = context! {
-            path => self.path,
-            time => timestamp.into_time().t(),
-            name => id.to_string(),
-            properties => properties.map(|p| build_property_string(p)),
-            node_type => node_type
-        };
+    ) -> Result<PyRemoteNode, ClientError> {
+        let graph = Arc::clone(&self.graph);
+        let node_type = node_type.map(|s| s.to_string());
 
-        let query = build_query(template, query_context)?;
-        let _ = &self.client.query(py, query, None)?;
+        let node = execute_async_task(move || async move {
+            graph.add_node(timestamp, id, properties, node_type).await
+        })?;
 
-        Ok(PyRemoteNode::new(
-            self.path.clone(),
-            self.client.clone(),
-            id.to_string(),
-        ))
+        Ok(PyRemoteNode::new(node))
     }
 
     /// Create a new node with the given id and properties to the remote graph and fail if the node already exists.
@@ -251,38 +253,21 @@ impl PyRemoteGraph {
     #[pyo3(signature = (timestamp, id, properties = None, node_type = None))]
     pub fn create_node(
         &self,
-        py: Python,
         timestamp: EventTime,
         id: GID,
         properties: Option<HashMap<String, Prop>>,
         node_type: Option<&str>,
-    ) -> Result<PyRemoteNode, GraphError> {
-        let template = r#"
-        {
-            updateGraph(path: "{{ path }}") {
-                createNode(time: {{ time }}, name: "{{ name }}" {% if properties is not none %}, properties:  {{ properties | safe }} {% endif %}{% if node_type is not none %}, nodeType: "{{ node_type }}"{% endif %}) {
-                    success
-                }
-            }
-        }
-        "#;
+    ) -> Result<PyRemoteNode, ClientError> {
+        let graph = Arc::clone(&self.graph);
+        let node_type = node_type.map(|s| s.to_string());
 
-        let query_context = context! {
-            path => self.path,
-            time => timestamp.into_time().t(),
-            name => id.to_string(),
-            properties => properties.map(|p| build_property_string(p)),
-            node_type => node_type
-        };
-
-        let query = build_query(template, query_context)?;
-        let _ = &self.client.query(py, query, None)?;
+        let node = execute_async_task(move || async move {
+            graph
+                .create_node(timestamp, id, properties, node_type)
+                .await
+        })?;
 
-        Ok(PyRemoteNode::new(
-            self.path.clone(),
-            self.client.clone(),
-            id.to_string(),
-        ))
+        Ok(PyRemoteNode::new(node))
     }
 
     /// Adds properties to the remote graph.
@@ -295,27 +280,11 @@ impl PyRemoteGraph {
     ///     None:
     pub fn add_property(
         &self,
-        py: Python,
         timestamp: EventTime,
         properties: HashMap<String, Prop>,
-    ) -> Result<(), GraphError> {
-        let template = r#"
-        {
-          updateGraph(path: "{{ path }}") {
-            addProperties(t: {{t}} properties: {{ properties | safe }})
-          }
-        }
-        "#;
-        let query_context = context! {
-            path => self.path,
-            t => timestamp.into_time().t(),
-            properties => build_property_string(properties),
-        };
-
-        let query = build_query(template, query_context)?;
-        let _ = &self.client.query(py, query, None)?;
-
-        Ok(())
+    ) -> Result<(), ClientError> {
+        let graph = Arc::clone(&self.graph);
+        execute_async_task(move || async move { graph.add_property(timestamp, properties).await })
     }
 
     /// Adds metadata to the remote graph.
@@ -325,28 +294,9 @@ impl PyRemoteGraph {
     ///
     /// Returns:
     ///     None:
-    pub fn add_metadata(
-        &self,
-        py: Python,
-        properties: HashMap<String, Prop>,
-    ) -> Result<(), GraphError> {
-        let template = r#"
-        {
-          updateGraph(path: "{{ path }}") {
-            addMetadata(properties: {{ properties | safe }})
-          }
-        }
-        "#;
-
-        let query_context = context! {
-            path => self.path,
-            properties => build_property_string(properties),
-        };
-
-        let query = build_query(template, query_context)?;
-        let _ = &self.client.query(py, query, None)?;
-
-        Ok(())
+    pub fn add_metadata(&self, properties: HashMap<String, Prop>) -> Result<(), ClientError> {
+        let graph = Arc::clone(&self.graph);
+        execute_async_task(move || async move { graph.add_metadata(properties).await })
     }
 
     /// Updates metadata on the remote graph.
@@ -356,29 +306,9 @@ impl PyRemoteGraph {
     ///
     /// Returns:
     ///     None:
-    pub fn update_metadata(
-        &self,
-        py: Python,
-        properties: HashMap<String, Prop>,
-    ) -> Result<(), GraphError> {
-        let template = r#"
-        {
-          updateGraph(path: "{{ path }}") {
-            updateMetadata(properties: {{ properties | safe }})
-          }
-        }
-        "#;
-
-        let query_context = context! {
-            path => self.path,
-            properties => build_property_string(properties),
-        };
-
-        let query = build_query(template, query_context)?;
-
-        let _ = &self.client.query(py, query, None)?;
-
-        Ok(())
+    pub fn update_metadata(&self, properties: HashMap<String, Prop>) -> Result<(), ClientError> {
+        let graph = Arc::clone(&self.graph);
+        execute_async_task(move || async move { graph.update_metadata(properties).await })
     }
 
     /// Adds a new edge with the given source and destination nodes and properties to the remote graph.
@@ -395,40 +325,20 @@ impl PyRemoteGraph {
     #[pyo3(signature = (timestamp, src, dst, properties = None, layer = None))]
     pub fn add_edge(
         &self,
-        py: Python,
         timestamp: EventTime,
         src: GID,
         dst: GID,
         properties: Option<HashMap<String, Prop>>,
         layer: Option<&str>,
-    ) -> Result<PyRemoteEdge, GraphError> {
-        let template = r#"
-        {
-            updateGraph(path: "{{ path }}") {
-                addEdge(time: {{ time }}, src: "{{ src }}", dst: "{{ dst }}" {% if properties is not none %}, properties:  {{ properties | safe }} {% endif %}{% if layer is not none %}, layer: "{{ layer }}"{% endif %}) {
-                    success
-                }
-            }
-        }
-        "#;
+    ) -> Result<PyRemoteEdge, ClientError> {
+        let graph = Arc::clone(&self.graph);
+        let layer = layer.map(|s| s.to_string());
 
-        let query_context = context! {
-            path => self.path,
-            time => timestamp.into_time().t(),
-            src => src.to_string(),
-            dst => dst.to_string(),
-            properties => properties.map(|p| build_property_string(p)),
-            layer => layer
-        };
+        let edge = execute_async_task(move || async move {
+            graph.add_edge(timestamp, src, dst, properties, layer).await
+        })?;
 
-        let query = build_query(template, query_context)?;
-        let _ = &self.client.query(py, query, None)?;
-        Ok(PyRemoteEdge::new(
-            self.path.clone(),
-            self.client.clone(),
-            src.to_string(),
-            dst.to_string(),
-        ))
+        Ok(PyRemoteEdge::new(edge))
     }
 
     /// Deletes an edge in the remote graph, given the timestamp, src and dst nodes and layer (optional)
@@ -444,37 +354,18 @@ impl PyRemoteGraph {
     #[pyo3(signature = (timestamp, src, dst, layer=None))]
     pub fn delete_edge(
         &self,
-        py: Python,
         timestamp: EventTime,
         src: GID,
         dst: GID,
         layer: Option<&str>,
-    ) -> Result<PyRemoteEdge, GraphError> {
-        let template = r#"
-        {
-            updateGraph(path: "{{ path }}") {
-                deleteEdge(time: {{ time }}, src: "{{ src }}", dst: "{{ dst }}" {% if layer is not none %}, layer: "{{ layer }}"{% endif %}) {
-                    success
-                }
-            }
-        }
-        "#;
+    ) -> Result<PyRemoteEdge, ClientError> {
+        let graph = Arc::clone(&self.graph);
+        let layer = layer.map(|s| s.to_string());
 
-        let query_context = context! {
-            path => self.path,
-            time => timestamp.into_time().t(),
-            src => src.to_string(),
-            dst => dst.to_string(),
-            layer => layer
-        };
+        let edge = execute_async_task(move || async move {
+            graph.delete_edge(timestamp, src, dst, layer).await
+        })?;
 
-        let query = build_query(template, query_context)?;
-        let _ = &self.client.query(py, query, None)?;
-        Ok(PyRemoteEdge::new(
-            self.path.clone(),
-            self.client.clone(),
-            src.to_string(),
-            dst.to_string(),
-        ))
+        Ok(PyRemoteEdge::new(edge))
     }
 }
diff --git a/raphtory-graphql/src/python/client/remote_node.rs b/raphtory-graphql/src/python/client/remote_node.rs
index 71d924d95c..0bee71661b 100644
--- a/raphtory-graphql/src/python/client/remote_node.rs
+++ b/raphtory-graphql/src/python/client/remote_node.rs
@@ -1,22 +1,13 @@
-use crate::python::client::{
-    build_property_string, build_query, raphtory_client::PyRaphtoryClient,
-};
-use minijinja::context;
-use pyo3::{pyclass, pymethods, Python};
-use raphtory::errors::GraphError;
-use raphtory_api::core::{
-    entities::properties::prop::Prop,
-    storage::timeindex::{AsTime, EventTime},
-    utils::time::IntoTime,
-};
-use std::collections::HashMap;
+use crate::client::{remote_node::GraphQLRemoteNode, ClientError};
+use pyo3::{pyclass, pymethods};
+use raphtory::python::utils::execute_async_task;
+use raphtory_api::core::{entities::properties::prop::Prop, storage::timeindex::EventTime};
+use std::{collections::HashMap, sync::Arc};
 
 #[derive(Clone)]
 #[pyclass(name = "RemoteNode", module = "raphtory.graphql")]
 pub struct PyRemoteNode {
-    pub(crate) path: String,
-    pub(crate) client: PyRaphtoryClient,
-    pub(crate) id: String,
+    pub(crate) node: Arc<GraphQLRemoteNode>,
 }
 
 impl PyRemoteNode {
@@ -29,8 +20,10 @@ impl PyRemoteNode {
     ///
     /// Returns:
     ///   None:
-    pub(crate) fn new(path: String, client: PyRaphtoryClient, id: String) -> Self {
-        Self { path, client, id }
+    pub(crate) fn new(node: GraphQLRemoteNode) -> Self {
+        Self {
+            node: Arc::new(node),
+        }
     }
 }
 
@@ -44,25 +37,12 @@ impl PyRemoteNode {
     ///
     /// Returns:
     ///   None:
-    pub fn set_node_type(&self, py: Python, new_type: &str) -> Result<(), GraphError> {
-        let template = r#"
-            {
-              updateGraph(path: "{{path}}") {
-                node(name: "{{name}}") {
-                  setNodeType(newType: "{{new_type}}")
-                }
-              }
-            }
-        "#;
+    pub fn set_node_type(&self, new_type: &str) -> Result<(), ClientError> {
+        let node = Arc::clone(&self.node);
+        let new_type = new_type.to_string();
 
-        let query_context = context! {
-            path => self.path,
-            name => self.id,
-            new_type => new_type
-        };
-
-        let query = build_query(template, query_context)?;
-        let _ = &self.client.query(py, query, None)?;
+        let task = move || async move { node.set_node_type(new_type).await };
+        execute_async_task(task)?;
         Ok(())
     }
 
@@ -78,29 +58,13 @@ impl PyRemoteNode {
     #[pyo3(signature = (t, properties=None))]
     pub fn add_updates(
         &self,
-        py: Python,
         t: EventTime,
         properties: Option<HashMap<String, Prop>>,
-    ) -> Result<(), GraphError> {
-        let template = r#"
-            {
-              updateGraph(path: "{{path}}") {
-                node(name: "{{name}}") {
-                  addUpdates(time: {{t}} {% if properties is not none %}, properties:  {{ properties | safe }} {% endif %})
-                }
-              }
-            }
-        "#;
-
-        let query_context = context! {
-            path => self.path,
-            name => self.id,
-            t => t.into_time().t(),
-            properties =>  properties.map(|p| build_property_string(p)),
-        };
+    ) -> Result<(), ClientError> {
+        let node = Arc::clone(&self.node);
 
-        let query = build_query(template, query_context)?;
-        let _ = &self.client.query(py, query, None)?;
+        let task = move || async move { node.add_updates(t, properties).await };
+        execute_async_task(task)?;
 
         Ok(())
     }
@@ -114,29 +78,11 @@ impl PyRemoteNode {
     ///
     /// Returns:
     ///   None:
-    pub fn add_metadata(
-        &self,
-        py: Python,
-        properties: HashMap<String, Prop>,
-    ) -> Result<(), GraphError> {
-        let template = r#"
-            {
-              updateGraph(path: "{{path}}") {
-                node(name: "{{name}}") {
-                  addMetadata(properties: {{ properties | safe }} )
-                }
-              }
-            }
-        "#;
+    pub fn add_metadata(&self, properties: HashMap<String, Prop>) -> Result<(), ClientError> {
+        let node = Arc::clone(&self.node);
 
-        let query_context = context! {
-            path => self.path,
-            name => self.id,
-            properties =>  build_property_string(properties),
-        };
-
-        let query = build_query(template, query_context)?;
-        let _ = &self.client.query(py, query, None)?;
+        let task = move || async move { node.add_metadata(properties).await };
+        execute_async_task(task)?;
         Ok(())
     }
 
@@ -149,29 +95,11 @@ impl PyRemoteNode {
     ///
     /// Returns:
     ///   None:
-    pub fn update_metadata(
-        &self,
-        py: Python,
-        properties: HashMap<String, Prop>,
-    ) -> Result<(), GraphError> {
-        let template = r#"
-            {
-              updateGraph(path: "{{path}}") {
-                node(name: "{{name}}") {
-                  updateMetadata(properties: {{ properties | safe }} )
-                }
-              }
-            }
-        "#;
-
-        let query_context = context! {
-            path => self.path,
-            name => self.id,
-            properties =>  build_property_string(properties)
-        };
+    pub fn update_metadata(&self, properties: HashMap<String, Prop>) -> Result<(), ClientError> {
+        let node = Arc::clone(&self.node);
 
-        let query = build_query(template, query_context)?;
-        let _ = &self.client.query(py, query, None)?;
+        let task = move || async move { node.update_metadata(properties).await };
+        execute_async_task(task)?;
         Ok(())
     }
 }
diff --git a/raphtory-graphql/src/python/mod.rs b/raphtory-graphql/src/python/mod.rs
index 0292834874..64edf44a76 100644
--- a/raphtory-graphql/src/python/mod.rs
+++ b/raphtory-graphql/src/python/mod.rs
@@ -1,6 +1,7 @@
 use crate::{
     model::App,
     url_encode::{url_decode_graph, url_encode_graph, UrlDecodeError},
+    GQLError,
 };
 use pyo3::{
     exceptions::{PyTypeError, PyValueError},
@@ -8,7 +9,7 @@ use pyo3::{
     types::{PyDict, PyList, PyNone},
     IntoPyObjectExt,
 };
-use raphtory::db::api::view::MaterializedGraph;
+use raphtory::db::api::{storage::storage::Config, view::MaterializedGraph};
 use raphtory_api::python::error::adapt_err_value;
 use serde_json::{Map, Number, Value as JsonValue};
 
@@ -86,8 +87,8 @@ fn translate_to_python(py: Python, value: serde_json::Value) -> PyResult<Bound<P
 
 /// Returns the raphtory graphql server schema
 ///
-/// Returns
-/// str: Graphql schema
+/// Returns:
+///     str: Graphql schema
 #[pyfunction]
 pub fn schema() -> String {
     let schema = App::create_schema().finish().unwrap(); //will only fail if something wrong with the build
@@ -97,10 +98,10 @@ pub fn schema() -> String {
 /// Encode a graph using Base64 encoding
 ///
 /// Arguments:
-/// graph (Graph | PersistentGraph): the graph
+///     graph (Graph | PersistentGraph): the graph
 ///
 /// Returns:
-/// str: the encoded graph
+///     str: the encoded graph
 #[pyfunction]
 pub(crate) fn encode_graph(graph: MaterializedGraph) -> PyResult<String> {
     let result = url_encode_graph(graph);
@@ -113,13 +114,13 @@ pub(crate) fn encode_graph(graph: MaterializedGraph) -> PyResult<String> {
 /// Decode a Base64-encoded graph
 ///
 /// Arguments:
-/// graph (str): the encoded graph
+///     graph (str): the encoded graph
 ///
 /// Returns:
-/// Union[Graph, PersistentGraph]: the decoded graph
+///     Union[Graph, PersistentGraph]: the decoded graph
 #[pyfunction]
 pub(crate) fn decode_graph(graph: &str) -> PyResult<MaterializedGraph> {
-    let result = url_decode_graph(graph);
+    let result = url_decode_graph(graph, Config::default());
     match result {
         Ok(g) => Ok(g),
         Err(e) => Err(PyValueError::new_err(format!("Error decoding: {:?}", e))),
@@ -131,3 +132,9 @@ impl From<UrlDecodeError> for PyErr {
         adapt_err_value(&value)
     }
 }
+
+impl From<GQLError> for PyErr {
+    fn from(value: GQLError) -> Self {
+        adapt_err_value(&value)
+    }
+}
diff --git a/raphtory-graphql/src/python/pymodule.rs b/raphtory-graphql/src/python/pymodule.rs
index 53c00759b6..d1a1794417 100644
--- a/raphtory-graphql/src/python/pymodule.rs
+++ b/raphtory-graphql/src/python/pymodule.rs
@@ -13,6 +13,15 @@ use crate::{
 };
 use pyo3::prelude::*;
 
+/// Returns True if the permissions extension (raphtory-auth) is compiled in.
+///
+/// Returns:
+///     bool: True if the extension is built in, False otherwise.
+#[pyfunction]
+pub fn has_permissions_extension() -> bool {
+    crate::server::has_server_extension()
+}
+
 pub fn base_graphql_module(py: Python<'_>) -> Result<Bound<'_, PyModule>, PyErr> {
     let graphql_module = PyModule::new(py, "graphql")?;
     graphql_module.add_class::<PyGraphServer>()?;
@@ -33,6 +42,10 @@ pub fn base_graphql_module(py: Python<'_>) -> Result<Bound<'_, PyModule>, PyErr>
     graphql_module.add_function(wrap_pyfunction!(decode_graph, &graphql_module)?)?;
     graphql_module.add_function(wrap_pyfunction!(schema, &graphql_module)?)?;
     graphql_module.add_function(wrap_pyfunction!(python_cli, &graphql_module)?)?;
+    graphql_module.add_function(wrap_pyfunction!(
+        has_permissions_extension,
+        &graphql_module
+    )?)?;
 
     Ok(graphql_module)
 }
diff --git a/raphtory-graphql/src/python/server/mod.rs b/raphtory-graphql/src/python/server/mod.rs
index fdd38ac2d1..4a33de6e01 100644
--- a/raphtory-graphql/src/python/server/mod.rs
+++ b/raphtory-graphql/src/python/server/mod.rs
@@ -20,9 +20,3 @@ pub(crate) fn wait_server(running_server: &mut Option<ServerHandler>) -> PyResul
         .expect("error when waiting for the server thread to complete")
         .map_err(|e| adapt_err_value(&e))
 }
-
-pub(crate) fn is_online(url: &String) -> bool {
-    reqwest::blocking::get(url)
-        .map(|response| response.status().as_u16() == 200)
-        .unwrap_or(false)
-}
diff --git a/raphtory-graphql/src/python/server/running_server.rs b/raphtory-graphql/src/python/server/running_server.rs
index bd8d33b907..7b464d0bdd 100644
--- a/raphtory-graphql/src/python/server/running_server.rs
+++ b/raphtory-graphql/src/python/server/running_server.rs
@@ -1,10 +1,13 @@
-use crate::python::{
-    client::raphtory_client::PyRaphtoryClient,
-    server::{is_online, wait_server, BridgeCommand},
-    RUNNING_SERVER_CONSUMED_MSG, WAIT_CHECK_INTERVAL_MILLIS,
+use crate::{
+    client::is_online,
+    python::{
+        client::raphtory_client::PyRaphtoryClient,
+        server::{wait_server, BridgeCommand},
+        RUNNING_SERVER_CONSUMED_MSG, WAIT_CHECK_INTERVAL_MILLIS,
+    },
 };
 use crossbeam_channel::Sender as CrossbeamSender;
-use pyo3::{exceptions::PyException, pyclass, pymethods, Py, PyObject, PyResult, Python};
+use pyo3::{exceptions::PyException, pyclass, pymethods, Py, PyAny, PyResult, Python};
 use std::{
     thread::{sleep, JoinHandle},
     time::Duration,
@@ -79,16 +82,16 @@ impl PyRunningGraphServer {
             Ok(())
         })?;
         let server = &mut self.server_handler;
-        py.allow_threads(|| wait_server(server))
+        py.detach(|| wait_server(server))
     }
 }
 
 #[pymethods]
 impl PyRunningGraphServer {
-    /// Get the client for the server
+    /// Get the client for the server.
     ///
     /// Returns:
-    /// RaphtoryClient: the client
+    ///     RaphtoryClient: the client.
     pub(crate) fn get_client(&self) -> PyResult<PyRaphtoryClient> {
         // TODO: return an authenticated server with rw access to everything?
         self.apply_if_alive(|handler| {
@@ -98,10 +101,10 @@ impl PyRunningGraphServer {
         })
     }
 
-    /// Stop the server and wait for it to finish
+    /// Stop the server and wait for it to finish.
     ///
     /// Returns:
-    /// None:
+    ///     None:
     pub(crate) fn stop(&mut self, py: Python) -> PyResult<()> {
         self.stop_server(py)
     }
@@ -113,9 +116,9 @@ impl PyRunningGraphServer {
     fn __exit__(
         &mut self,
         py: Python,
-        _exc_type: PyObject,
-        _exc_val: PyObject,
-        _exc_tb: PyObject,
+        _exc_type: Py<PyAny>,
+        _exc_val: Py<PyAny>,
+        _exc_tb: Py<PyAny>,
     ) -> PyResult<()> {
         self.stop_server(py)
     }
diff --git a/raphtory-graphql/src/python/server/server.rs b/raphtory-graphql/src/python/server/server.rs
index f8c4f8703c..3fccbe0aa0 100644
--- a/raphtory-graphql/src/python/server/server.rs
+++ b/raphtory-graphql/src/python/server/server.rs
@@ -4,6 +4,7 @@ use crate::{
         otlp_config::TracingLevel,
     },
     python::server::{running_server::PyRunningGraphServer, wait_server, BridgeCommand},
+    server::apply_server_extension,
     GraphServer,
 };
 use pyo3::{
@@ -11,6 +12,7 @@ use pyo3::{
     prelude::*,
 };
 use raphtory::{
+    db::api::storage::storage::Config,
     python::{
         packages::vectors::{PyOpenAIEmbeddings, TemplateConfig},
         utils::block_on,
@@ -27,13 +29,26 @@ use std::{path::PathBuf, thread};
 ///     cache_tti_seconds (int, optional): the inactive time in seconds after which a graph is evicted from the cache
 ///     log_level (str, optional): the log level for the server
 ///     tracing (bool, optional): whether tracing should be enabled
+///     tracing_level (str, optional): tracing verbosity (e.g. "ERROR", "WARN", "INFO", "DEBUG", "TRACE").
 ///     otlp_agent_host (str, optional): OTLP agent host for tracing
 ///     otlp_agent_port(str, optional): OTLP agent port for tracing
 ///     otlp_tracing_service_name (str, optional): The OTLP tracing service name
 ///     config_path (str | PathLike, optional): Path to the config file
-///     auth_public_key:
-///     auth_enabled_for_reads:
-///     create_index:
+///     auth_public_key (str, optional): Base64-encoded public key used to verify bearer tokens
+///     require_auth_for_reads (bool, optional): Require auth tokens for read queries
+///     create_index (bool, optional): Build a search index on startup
+///     heavy_query_limit (int, optional): Maximum number of expensive traversal queries (outComponent, inComponent, edges, outEdges, inEdges, neighbours, outNeighbours, inNeighbours) allowed to run simultaneously. Extra queries are parked on a semaphore.
+///     exclusive_writes (bool, optional): If True, ingestion/write operations run one at a time and block reads until complete.
+///     disable_batching (bool, optional): If True, batched GraphQL requests are rejected. Prevents bypassing per-request depth/complexity limits.
+///     max_batch_size (int, optional): Caps the number of queries accepted in a single batched request.
+///     disable_lists (bool, optional): If True, bulk `list` endpoints on collections are disabled. Clients must use `page` instead.
+///     max_page_size (int, optional): Maximum page size allowed on paged collection queries.
+///     max_query_depth (int, optional): Maximum nesting depth of a query.
+///     max_query_complexity (int, optional): Maximum estimated cost of a query, based on the number of fields selected.
+///     max_recursive_depth (int, optional): Internal safety limit to prevent stack overflows from pathologically structured queries (async-graphql default is 32).
+///     max_directives_per_field (int, optional): Maximum number of directives on any single field.
+///     disable_introspection (bool, optional): If True, schema introspection is disabled entirely.
+///     permissions_store_path (str | PathLike, optional): Path to the permissions store (used by the optional auth extension).
 #[pyclass(name = "GraphServer", module = "raphtory.graphql")]
 pub struct PyGraphServer(GraphServer);
 
@@ -67,7 +82,33 @@ fn template_from_python(
 impl PyGraphServer {
     #[new]
     #[pyo3(
-        signature = (work_dir, cache_capacity = None, cache_tti_seconds = None, log_level = None, tracing=None, tracing_level=None, otlp_agent_host=None, otlp_agent_port=None, otlp_tracing_service_name=None, auth_public_key=None, auth_enabled_for_reads=None, config_path = None, create_index = None)
+        signature = (
+            work_dir,
+            cache_capacity = None,
+            cache_tti_seconds = None,
+            log_level = None,
+            tracing=None,
+            tracing_level=None,
+            otlp_agent_host=None,
+            otlp_agent_port=None,
+            otlp_tracing_service_name=None,
+            auth_public_key=None,
+            require_auth_for_reads=None,
+            config_path = None,
+            create_index = None,
+            heavy_query_limit = None,
+            exclusive_writes = None,
+            disable_batching = None,
+            max_batch_size = None,
+            disable_lists = None,
+            max_page_size = None,
+            max_query_depth = None,
+            max_query_complexity = None,
+            max_recursive_depth = None,
+            max_directives_per_field = None,
+            disable_introspection = None,
+            permissions_store_path = None
+        )
     )]
     fn py_new(
         work_dir: PathBuf,
@@ -80,9 +121,21 @@ impl PyGraphServer {
         otlp_agent_port: Option<String>,
         otlp_tracing_service_name: Option<String>,
         auth_public_key: Option<String>,
-        auth_enabled_for_reads: Option<bool>,
+        require_auth_for_reads: Option<bool>,
         config_path: Option<PathBuf>,
         create_index: Option<bool>,
+        heavy_query_limit: Option<usize>,
+        exclusive_writes: Option<bool>,
+        disable_batching: Option<bool>,
+        max_batch_size: Option<usize>,
+        disable_lists: Option<bool>,
+        max_page_size: Option<usize>,
+        max_query_depth: Option<usize>,
+        max_query_complexity: Option<usize>,
+        max_recursive_depth: Option<usize>,
+        max_directives_per_field: Option<usize>,
+        disable_introspection: Option<bool>,
+        permissions_store_path: Option<PathBuf>,
     ) -> PyResult<Self> {
         let mut app_config_builder = AppConfigBuilder::new();
         if let Some(log_level) = log_level {
@@ -120,22 +173,66 @@ impl PyGraphServer {
         app_config_builder = app_config_builder
             .with_auth_public_key(auth_public_key)
             .map_err(|_| PyValueError::new_err(PUBLIC_KEY_DECODING_ERR_MSG))?;
-        if let Some(auth_enabled_for_reads) = auth_enabled_for_reads {
+        if let Some(require_auth_for_reads) = require_auth_for_reads {
             app_config_builder =
-                app_config_builder.with_auth_enabled_for_reads(auth_enabled_for_reads);
+                app_config_builder.with_require_auth_for_reads(require_auth_for_reads);
         }
         #[cfg(feature = "search")]
         if let Some(create_index) = create_index {
             app_config_builder = app_config_builder.with_create_index(create_index);
         }
+        if heavy_query_limit.is_some() {
+            app_config_builder = app_config_builder.with_heavy_query_limit(heavy_query_limit);
+        }
+        if let Some(exclusive_writes) = exclusive_writes {
+            app_config_builder = app_config_builder.with_exclusive_writes(exclusive_writes);
+        }
+        if let Some(disable_batching) = disable_batching {
+            app_config_builder = app_config_builder.with_disable_batching(disable_batching);
+        }
+        if max_batch_size.is_some() {
+            app_config_builder = app_config_builder.with_max_batch_size(max_batch_size);
+        }
+        if let Some(disable_lists) = disable_lists {
+            app_config_builder = app_config_builder.with_disable_lists(disable_lists);
+        }
+        if max_page_size.is_some() {
+            app_config_builder = app_config_builder.with_max_page_size(max_page_size);
+        }
+        if max_query_depth.is_some() {
+            app_config_builder = app_config_builder.with_max_query_depth(max_query_depth);
+        }
+        if max_query_complexity.is_some() {
+            app_config_builder = app_config_builder.with_max_query_complexity(max_query_complexity);
+        }
+        if max_recursive_depth.is_some() {
+            app_config_builder = app_config_builder.with_max_recursive_depth(max_recursive_depth);
+        }
+        if max_directives_per_field.is_some() {
+            app_config_builder =
+                app_config_builder.with_max_directives_per_field(max_directives_per_field);
+        }
+        if let Some(disable_introspection) = disable_introspection {
+            app_config_builder =
+                app_config_builder.with_disable_introspection(disable_introspection);
+        }
         let app_config = Some(app_config_builder.build());
 
-        let server = block_on(GraphServer::new(work_dir, app_config, config_path))?;
+        let server = block_on(GraphServer::new(
+            work_dir,
+            app_config,
+            config_path,
+            Config::default(),
+        ))?;
+        let server = apply_server_extension(server, permissions_store_path.as_deref());
         Ok(PyGraphServer(server))
     }
 
     // TODO: remove this, should be config
-    /// Turn off index for all graphs
+    /// Turn off index for all graphs.
+    ///
+    /// Returns:
+    ///     None:
     fn turn_off_index(mut slf: PyRefMut<Self>) {
         slf.0.turn_off_index()
     }
@@ -147,6 +244,9 @@ impl PyGraphServer {
     ///     embeddings (OpenAIEmbeddings): the embeddings to use
     ///     nodes (bool | str): if nodes have to be embedded or not or the custom template to use if a str is provided. Defaults to True.
     ///     edges (bool | str): if edges have to be embedded or not or the custom template to use if a str is provided. Defaults to True.
+    ///
+    /// Returns:
+    ///     None:
     #[pyo3(
         signature = (name, embeddings, nodes = TemplateConfig::Bool(true), edges = TemplateConfig::Bool(true))
     )]
@@ -160,7 +260,7 @@ impl PyGraphServer {
     ) -> PyResult<()> {
         let template = template_from_python(nodes, edges)?;
         // allow threads just in case the embedding server is using the same python runtime
-        py.allow_threads(|| {
+        py.detach(|| {
             block_on(async move {
                 self.0
                     .vectorise_graph(name, &template, embeddings.into())
@@ -176,6 +276,9 @@ impl PyGraphServer {
     ///     embeddings (OpenAIEmbeddings): the embeddings to use
     ///     nodes (bool | str): if nodes have to be embedded or not or the custom template to use if a str is provided. Defaults to True.
     ///     edges (bool | str): if edges have to be embedded or not or the custom template to use if a str is provided. Defaults to True.
+    ///
+    /// Returns:
+    ///     None:
     #[pyo3(
         signature = (embeddings, nodes = TemplateConfig::Bool(true), edges = TemplateConfig::Bool(true))
     )]
@@ -188,7 +291,7 @@ impl PyGraphServer {
     ) -> PyResult<()> {
         let template = template_from_python(nodes, edges)?;
         // allow threads just in case the embedding server is using the same python runtime
-        py.allow_threads(|| {
+        py.detach(|| {
             block_on(async move {
                 self.0
                     .vectorise_all_graphs(&template, embeddings.into())
@@ -264,6 +367,6 @@ impl PyGraphServer {
     )]
     pub fn run(&self, py: Python, port: u16, timeout_ms: u64) -> PyResult<()> {
         let mut server = self.start(py, port, timeout_ms)?.server_handler;
-        py.allow_threads(|| wait_server(&mut server))
+        py.detach(|| wait_server(&mut server))
     }
 }
diff --git a/raphtory-graphql/src/rayon.rs b/raphtory-graphql/src/rayon.rs
index 83650b0ae4..03d44238fc 100644
--- a/raphtory-graphql/src/rayon.rs
+++ b/raphtory-graphql/src/rayon.rs
@@ -37,16 +37,16 @@ pub async fn blocking_write<R: Send + 'static, F: FnOnce() -> R + Send + 'static
 
 #[cfg(test)]
 mod deadlock_tests {
-    use parking_lot::Mutex;
-    use reqwest::{Client, StatusCode};
-    use std::{sync::Arc, time::Duration};
-    use tempfile::TempDir;
-
     use crate::{
         rayon::{COMPUTE_POOL, WRITE_POOL},
         routes::Health,
         GraphServer,
     };
+    use parking_lot::Mutex;
+    use raphtory::db::api::storage::storage::Config;
+    use reqwest::{Client, StatusCode};
+    use std::{sync::Arc, time::Duration};
+    use tempfile::TempDir;
 
     #[tokio::test]
     async fn test_deadlock_in_read_pool() {
@@ -70,7 +70,7 @@ mod deadlock_tests {
 
     async fn test_pool_lock(port: u16, pool_lock: impl FnOnce(Arc<Mutex<()>>)) {
         let tempdir = TempDir::new().unwrap();
-        let server = GraphServer::new(tempdir.path().to_path_buf(), None, None)
+        let server = GraphServer::new(tempdir.path().to_path_buf(), None, None, Config::default())
             .await
             .unwrap();
         let _running = server.start_with_port(port).await.unwrap();
diff --git a/raphtory-graphql/src/routes.rs b/raphtory-graphql/src/routes.rs
index 7d779f91a7..18085534bd 100644
--- a/raphtory-graphql/src/routes.rs
+++ b/raphtory-graphql/src/routes.rs
@@ -13,8 +13,8 @@ use std::{path::PathBuf, time::Duration};
 use crate::rayon::{blocking_compute, blocking_write};
 
 #[derive(Serialize, Deserialize)]
-pub(super) struct Health {
-    pub(super) healthy: bool,
+pub(crate) struct Health {
+    pub(crate) healthy: bool,
 }
 
 #[derive(Serialize)]
diff --git a/raphtory-graphql/src/server.rs b/raphtory-graphql/src/server.rs
index b49d60a7fe..5f29083cb9 100644
--- a/raphtory-graphql/src/server.rs
+++ b/raphtory-graphql/src/server.rs
@@ -1,5 +1,6 @@
 use crate::{
     auth::{AuthenticatedGraphQL, MutationAuth},
+    auth_policy::AuthorizationPolicy,
     config::app_config::{load_config, AppConfig},
     data::Data,
     model::{
@@ -10,8 +11,10 @@ use crate::{
     paths::ExistingGraphFolder,
     routes::{health, version, PublicFilesEndpoint},
     server::ServerError::SchemaError,
+    GQLError,
 };
 use config::ConfigError;
+use once_cell::sync::Lazy;
 use opentelemetry::trace::TracerProvider;
 use opentelemetry_sdk::trace::{Tracer, TracerProvider as TP};
 use poem::{
@@ -22,11 +25,19 @@ use poem::{
     EndpointExt, Route, Server,
 };
 use raphtory::{
-    errors::GraphResult,
+    db::api::storage::storage::Config,
     vectors::{storage::OpenAIEmbeddings, template::DocumentTemplate},
 };
 use serde_json::json;
-use std::{fs::create_dir_all, path::PathBuf};
+use std::{
+    fs::create_dir_all,
+    future::Future,
+    ops::Deref,
+    path::{Path, PathBuf},
+    pin::Pin,
+    sync::RwLock,
+    task::{Context, Poll},
+};
 use thiserror::Error;
 use tokio::{
     io,
@@ -39,7 +50,7 @@ use tokio::{
     task,
     task::JoinHandle,
 };
-use tracing::{debug, info};
+use tracing::{debug, info, warn};
 use tracing_subscriber::{
     fmt, fmt::format::FmtSpan, layer::SubscriberExt, util::SubscriberInitExt, Registry,
 };
@@ -47,6 +58,25 @@ use url::ParseError;
 
 pub const DEFAULT_PORT: u16 = 1736;
 
+type ServerExtensionFn = Box<dyn Fn(GraphServer, Option<&Path>) -> GraphServer + Send + Sync>;
+
+static SERVER_EXTENSION: Lazy<RwLock<Option<ServerExtensionFn>>> = Lazy::new(|| RwLock::new(None));
+
+pub fn register_server_extension(f: ServerExtensionFn) {
+    *SERVER_EXTENSION.write().unwrap() = Some(f);
+}
+
+pub fn apply_server_extension(server: GraphServer, path: Option<&Path>) -> GraphServer {
+    match SERVER_EXTENSION.read().unwrap().as_ref() {
+        Some(ext) => ext(server, path),
+        None => server,
+    }
+}
+
+pub fn has_server_extension() -> bool {
+    SERVER_EXTENSION.read().unwrap().is_some()
+}
+
 #[derive(Error, Debug)]
 pub enum ServerError {
     #[error("Config error: {0}")]
@@ -75,11 +105,18 @@ impl From<ServerError> for io::Error {
     }
 }
 
+type SchemaDataInjector = std::sync::Arc<
+    dyn Fn(async_graphql::dynamic::SchemaBuilder) -> async_graphql::dynamic::SchemaBuilder
+        + Send
+        + Sync,
+>;
+
 /// A struct for defining and running a Raphtory GraphQL server
 #[derive(Clone)]
 pub struct GraphServer {
     data: Data,
     config: AppConfig,
+    schema_data: Vec<SchemaDataInjector>,
 }
 
 pub fn register_query_plugin<
@@ -111,20 +148,49 @@ impl GraphServer {
         work_dir: PathBuf,
         app_config: Option<AppConfig>,
         config_path: Option<PathBuf>,
+        graph_config: Config,
     ) -> IoResult<Self> {
         if !work_dir.exists() {
             create_dir_all(&work_dir)?;
         }
         let config = load_config(app_config, config_path).map_err(ServerError::ConfigError)?;
-        let data = Data::new(work_dir.as_path(), &config);
-        Ok(Self { data, config })
+        let data = Data::new(work_dir.as_path(), &config, graph_config);
+        Ok(Self {
+            data,
+            config,
+            schema_data: Vec::new(),
+        })
+    }
+
+    /// Returns the working directory for this server.
+    pub fn work_dir(&self) -> &Path {
+        &self.data.work_dir
     }
 
-    /// Turn off index for all graphs
     pub fn turn_off_index(&mut self) {
         self.data.create_index = false; // FIXME: why does this exist yet?
     }
 
+    /// Set the authorization policy used for graph access checks.
+    pub fn with_auth_policy(mut self, policy: std::sync::Arc<dyn AuthorizationPolicy>) -> Self {
+        self.data.set_auth_policy(policy);
+        self
+    }
+
+    /// Inject arbitrary typed data into the GQL schema (accessible via `ctx.data::<T>()`).
+    pub fn with_schema_data<T: std::any::Any + Send + Sync + 'static>(mut self, data: T) -> Self {
+        let data = std::sync::Arc::new(std::sync::Mutex::new(Some(data)));
+        self.schema_data.push(std::sync::Arc::new(move |sb| {
+            let data = data
+                .lock()
+                .unwrap()
+                .take()
+                .expect("schema data injector called more than once");
+            sb.data(data)
+        }));
+        self
+    }
+
     /// Vectorise all the graphs in the server working directory.
     ///
     /// Arguments:
@@ -137,7 +203,7 @@ impl GraphServer {
         &self,
         template: &DocumentTemplate,
         embeddings: OpenAIEmbeddings,
-    ) -> GraphResult<()> {
+    ) -> Result<(), GQLError> {
         let vector_cache = self.data.vector_cache.resolve().await?;
         let model = vector_cache.openai(embeddings.into()).await?;
         for folder in self.data.get_all_graph_folders() {
@@ -148,7 +214,7 @@ impl GraphServer {
         Ok(())
     }
 
-    /// Vectorise the graph 'name'in the server working directory.
+    /// Vectorise the graph 'name' in the server working directory.
     ///
     /// Arguments:
     ///   * path - the path of the graph to vectorise.
@@ -158,7 +224,7 @@ impl GraphServer {
         path: &str,
         template: &DocumentTemplate,
         embeddings: OpenAIEmbeddings,
-    ) -> GraphResult<()> {
+    ) -> Result<(), GQLError> {
         let vetor_cache = self.data.vector_cache.resolve();
         let model = vetor_cache.await?.openai(embeddings.into()).await?;
         let folder = ExistingGraphFolder::try_from(self.data.work_dir.clone(), path)?;
@@ -199,13 +265,13 @@ impl GraphServer {
 
         // Otherwise evictions are only triggered when the cache is actively touched
         let cache_clone = self.data.cache.clone();
-        tokio::spawn(async move {
+        let cache_task: AbortOnDrop<()> = AbortOnDrop(tokio::spawn(async move {
             let mut interval = tokio::time::interval(std::time::Duration::from_secs(1));
             loop {
                 interval.tick().await;
                 cache_clone.run_pending_tasks().await;
             }
-        });
+        }));
 
         // it is important that this runs after algorithms have been pushed to PLUGIN_ALGOS static variable
         let app = self
@@ -225,11 +291,12 @@ impl GraphServer {
 
         let server_task = Server::new(TcpListener::bind(format!("0.0.0.0:{port}")))
             .run_with_graceful_shutdown(app, server_termination(signal_receiver, tp), None);
-        let server_result = tokio::spawn(server_task);
+        let server_result = AbortOnDrop(tokio::spawn(server_task));
 
         Ok(RunningGraphServer {
             signal_sender,
             server_result,
+            cache_task,
         })
     }
 
@@ -237,9 +304,29 @@ impl GraphServer {
         &self,
         tracer: Option<Tracer>,
     ) -> Result<CompressionEndpoint<CorsEndpoint<Route>>, ServerError> {
-        let schema_builder = App::create_schema();
-        let schema_builder = schema_builder.data(self.data.clone());
-        let schema_builder = schema_builder.extension(MutationAuth);
+        let schema_cfg = &self.config.schema;
+        let mut schema_builder = App::create_schema()
+            .data(self.data.clone())
+            .data(self.config.concurrency.clone());
+        for inject in &self.schema_data {
+            schema_builder = inject(schema_builder);
+        }
+        schema_builder = schema_builder.extension(MutationAuth);
+        if let Some(depth) = schema_cfg.max_query_depth {
+            schema_builder = schema_builder.limit_depth(depth);
+        }
+        if let Some(complexity) = schema_cfg.max_query_complexity {
+            schema_builder = schema_builder.limit_complexity(complexity);
+        }
+        if let Some(recursive_depth) = schema_cfg.max_recursive_depth {
+            schema_builder = schema_builder.limit_recursive_depth(recursive_depth);
+        }
+        if let Some(max_directives) = schema_cfg.max_directives_per_field {
+            schema_builder = schema_builder.limit_directives(max_directives);
+        }
+        if schema_cfg.disable_introspection {
+            schema_builder = schema_builder.disable_introspection();
+        }
         let trace_level = self.config.tracing.tracing_level.clone();
         let schema = if let Some(t) = tracer {
             schema_builder
@@ -255,7 +342,7 @@ impl GraphServer {
                 "/",
                 PublicFilesEndpoint::new(
                     self.config.public_dir.clone(),
-                    AuthenticatedGraphQL::new(schema, self.config.auth.clone()),
+                    AuthenticatedGraphQL::new(schema, self.config.clone()),
                 ),
             )
             .at("/health", get(health))
@@ -276,24 +363,49 @@ impl GraphServer {
     }
 }
 
+#[derive(Debug)]
+pub struct AbortOnDrop<T>(pub JoinHandle<T>);
+
+impl<T> Drop for AbortOnDrop<T> {
+    fn drop(&mut self) {
+        self.0.abort();
+    }
+}
+
+impl<T> Deref for AbortOnDrop<T> {
+    type Target = JoinHandle<T>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<T> Future for AbortOnDrop<T> {
+    type Output = <JoinHandle<T> as Future>::Output;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        Pin::new(&mut self.0).poll(cx)
+    }
+}
+
 /// A Raphtory server handler
 #[derive(Debug)]
 pub struct RunningGraphServer {
     signal_sender: Sender<()>,
-    server_result: JoinHandle<IoResult<()>>,
+    server_result: AbortOnDrop<IoResult<()>>,
+    cache_task: AbortOnDrop<()>,
 }
 
 impl RunningGraphServer {
     /// Stop the server.
     pub async fn stop(&self) {
+        self.cache_task.abort();
         let _ignored = self.signal_sender.send(()).await;
     }
 
     /// Wait until server completion.
     pub async fn wait(self) -> IoResult<()> {
-        self.server_result
-            .await
-            .expect("Couldn't join tokio task for the server")
+        self.server_result.await.expect("Server panicked")
     }
 
     // TODO: make this optional with some python feature flag
@@ -346,11 +458,9 @@ mod server_tests {
     use crate::server::GraphServer;
     use chrono::prelude::*;
     use raphtory::{
+        db::api::storage::storage::Config,
         prelude::{AdditionOps, Graph, StableEncode, NO_PROPS},
-        vectors::{
-            embeddings::EmbeddingResult, storage::OpenAIEmbeddings, template::DocumentTemplate,
-            Embedding,
-        },
+        vectors::{storage::OpenAIEmbeddings, template::DocumentTemplate},
     };
     use raphtory_api::core::utils::logging::global_info_logger;
     use tempfile::tempdir;
@@ -361,7 +471,7 @@ mod server_tests {
     async fn test_server_start_stop() {
         global_info_logger();
         let tmp_dir = tempdir().unwrap();
-        let server = GraphServer::new(tmp_dir.path().to_path_buf(), None, None)
+        let server = GraphServer::new(tmp_dir.path().to_path_buf(), None, None, Config::default())
             .await
             .unwrap();
         info!("Calling start at time {}", Local::now());
@@ -375,11 +485,11 @@ mod server_tests {
     async fn test_server_start_with_failing_embedding() {
         let tmp_dir = tempdir().unwrap();
         let graph = Graph::new();
-        graph.add_node(0, 0, NO_PROPS, None).unwrap();
+        graph.add_node(0, 0, NO_PROPS, None, None).unwrap();
         graph.encode(tmp_dir.path().join("g")).unwrap();
 
         global_info_logger();
-        let server = GraphServer::new(tmp_dir.path().to_path_buf(), None, None)
+        let server = GraphServer::new(tmp_dir.path().to_path_buf(), None, None, Config::default())
             .await
             .unwrap();
         let template = DocumentTemplate {
diff --git a/raphtory-graphql/src/url_encode.rs b/raphtory-graphql/src/url_encode.rs
index 017d3ab886..00009af1df 100644
--- a/raphtory-graphql/src/url_encode.rs
+++ b/raphtory-graphql/src/url_encode.rs
@@ -1,8 +1,12 @@
 use base64::{prelude::BASE64_URL_SAFE, DecodeError, Engine};
 use raphtory::{
-    db::api::view::MaterializedGraph,
+    db::api::{
+        storage::storage::{Config, Extension, PersistenceStrategy},
+        view::MaterializedGraph,
+    },
     errors::GraphError,
-    serialise::{InternalStableDecode, StableEncode},
+    prelude::{StableDecode, StableEncode},
+    serialise::GraphPaths,
 };
 
 #[derive(thiserror::Error, Debug)]
@@ -21,11 +25,56 @@ pub enum UrlDecodeError {
 
 pub fn url_encode_graph<G: Into<MaterializedGraph>>(graph: G) -> Result<String, GraphError> {
     let g: MaterializedGraph = graph.into();
-    Ok(BASE64_URL_SAFE.encode(g.encode_to_vec()))
+    let bytes = g.encode_to_bytes()?;
+
+    Ok(BASE64_URL_SAFE.encode(bytes))
+}
+
+pub fn url_decode_graph<T: AsRef<[u8]>>(
+    graph: T,
+    config: Config,
+) -> Result<MaterializedGraph, GraphError> {
+    let bytes = BASE64_URL_SAFE.decode(graph.as_ref()).unwrap();
+    MaterializedGraph::decode_from_bytes_with_config(&bytes, config)
 }
 
-pub fn url_decode_graph<T: AsRef<[u8]>>(graph: T) -> Result<MaterializedGraph, UrlDecodeError> {
-    Ok(MaterializedGraph::decode_from_bytes(
-        &BASE64_URL_SAFE.decode(graph)?,
-    )?)
+pub fn url_decode_graph_at<T: AsRef<[u8]>>(
+    graph: T,
+    storage_path: &(impl GraphPaths + ?Sized),
+    config: Config,
+) -> Result<MaterializedGraph, GraphError> {
+    let bytes = BASE64_URL_SAFE.decode(graph.as_ref()).unwrap();
+    if Extension::disk_storage_enabled() {
+        MaterializedGraph::decode_from_bytes_at(&bytes, storage_path, config)
+    } else {
+        MaterializedGraph::decode_from_bytes_with_config(&bytes, config)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use raphtory::{db::graph::graph::assert_graph_equal, prelude::*};
+
+    use super::*;
+
+    #[test]
+    fn test_url_encode_decode() {
+        let graph = Graph::new();
+        graph.add_edge(1, 2, 3, [("bla", "blu")], None).unwrap();
+        let edge = graph.add_edge(2, 3, 4, [("foo", 42)], Some("7")).unwrap();
+
+        edge.add_metadata([("14", 15f64)], Some("7")).unwrap();
+
+        let node = graph.add_node(17, 0, NO_PROPS, None, None).unwrap();
+        node.add_metadata([("blerg", "test")]).unwrap();
+
+        let bytes = url_encode_graph(graph.clone()).unwrap();
+        let tempdir = tempfile::tempdir().unwrap();
+        let storage_path = tempdir.path().to_path_buf();
+        let decoded_graph = url_decode_graph_at(bytes, &storage_path, Config::default()).unwrap();
+
+        let g2 = decoded_graph.into_events().unwrap();
+
+        assert_graph_equal(&graph, &g2);
+    }
 }
diff --git a/raphtory-itertools/Cargo.toml b/raphtory-itertools/Cargo.toml
new file mode 100644
index 0000000000..91539aeefa
--- /dev/null
+++ b/raphtory-itertools/Cargo.toml
@@ -0,0 +1,25 @@
+[package]
+name = "raphtory-itertools"
+version.workspace = true
+documentation.workspace = true
+repository.workspace = true
+license.workspace = true
+readme.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+authors.workspace = true
+rust-version.workspace = true
+edition.workspace = true
+
+[dependencies]
+itertools = { workspace = true }
+
+[dev-dependencies]
+proptest.workspace = true
+criterion = { workspace = true }
+rand = { workspace = true }
+
+
+[[bench]]
+name = "bench"
+harness = false
diff --git a/raphtory-itertools/benches/bench.rs b/raphtory-itertools/benches/bench.rs
new file mode 100644
index 0000000000..afb7121259
--- /dev/null
+++ b/raphtory-itertools/benches/bench.rs
@@ -0,0 +1,118 @@
+use criterion::{black_box, criterion_group, criterion_main, BatchSize, BenchmarkId, Criterion};
+use itertools::Itertools;
+use rand::{rngs::SmallRng, Rng, SeedableRng};
+use raphtory_itertools::FastMergeExt;
+
+fn bench(criterion: &mut Criterion) {
+    let mut rng = SmallRng::seed_from_u64(42);
+    let data: Vec<Vec<u64>> = (0..10)
+        .map(|_| {
+            let size = rng.random_range(0..100);
+            let mut inner: Vec<_> = (&mut rng).random_iter().take(size).collect();
+            inner.sort();
+            inner
+        })
+        .collect();
+    let mut merge_and_first = criterion.benchmark_group("merge sorted vecs and get first element");
+    for size in 0..=data.len() {
+        merge_and_first.bench_with_input(
+            BenchmarkId::new("kmerge", size),
+            &size,
+            |bencher, size| bencher.iter(|| data.iter().take(*size).kmerge().next()),
+        );
+        merge_and_first.bench_with_input(BenchmarkId::new("fast", size), &size, |bencher, size| {
+            bencher.iter(|| data.iter().take(*size).fast_merge().next())
+        });
+    }
+    merge_and_first.finish();
+
+    let mut merge_and_iter = criterion.benchmark_group("merge sorted vecs and iterate");
+    for size in 0..=data.len() {
+        merge_and_iter.bench_with_input(
+            BenchmarkId::new("kmerge", size),
+            &size,
+            |bencher, size| {
+                bencher.iter(|| {
+                    for i in data.iter().take(*size).kmerge() {
+                        black_box(i);
+                    }
+                })
+            },
+        );
+        merge_and_iter.bench_with_input(BenchmarkId::new("fast", size), &size, |bencher, size| {
+            bencher.iter(|| {
+                for i in data.iter().take(*size).fast_merge() {
+                    black_box(i);
+                }
+            })
+        });
+        merge_and_iter.bench_with_input(BenchmarkId::new("sort", size), &size, |bencher, size| {
+            bencher.iter(|| {
+                for i in data.iter().take(*size).flatten().sorted() {
+                    black_box(i);
+                }
+            })
+        });
+    }
+    merge_and_iter.finish();
+
+    let mut merge = criterion.benchmark_group("create merged iterator");
+    for size in 0..=data.len() {
+        merge.bench_with_input(BenchmarkId::new("kmerge", size), &size, |bencher, size| {
+            bencher.iter(|| data.iter().take(*size).kmerge())
+        });
+        merge.bench_with_input(BenchmarkId::new("fast", size), &size, |bencher, size| {
+            bencher.iter(|| data.iter().take(*size).fast_merge())
+        });
+    }
+    merge.finish();
+
+    let mut first_element = criterion.benchmark_group("get first element");
+    for size in 0..=data.len() {
+        first_element.bench_with_input(BenchmarkId::new("kmerge", size), &size, |bencher, size| {
+            bencher.iter_batched_ref(
+                || data.iter().take(*size).kmerge(),
+                |iter| iter.next(),
+                BatchSize::SmallInput,
+            )
+        });
+        first_element.bench_with_input(BenchmarkId::new("fast", size), &size, |bencher, size| {
+            bencher.iter_batched_ref(
+                || data.iter().take(*size).fast_merge(),
+                |iter| iter.next(),
+                BatchSize::SmallInput,
+            )
+        });
+    }
+    first_element.finish();
+
+    let mut iterate = criterion.benchmark_group("iterate over all elements");
+    for size in 0..=data.len() {
+        iterate.bench_with_input(BenchmarkId::new("kmerge", size), &size, |bencher, size| {
+            bencher.iter_batched_ref(
+                || data.iter().take(*size).kmerge(),
+                |iter| {
+                    for v in iter {
+                        black_box(v);
+                    }
+                },
+                BatchSize::SmallInput,
+            )
+        });
+        iterate.bench_with_input(BenchmarkId::new("fast", size), &size, |bencher, size| {
+            bencher.iter_batched_ref(
+                || data.iter().take(*size).fast_merge(),
+                |iter| {
+                    for v in iter {
+                        black_box(v);
+                    }
+                },
+                BatchSize::SmallInput,
+            )
+        });
+    }
+    iterate.finish();
+}
+
+criterion_group!(benches, bench);
+criterion_main!(benches);
diff --git a/raphtory-itertools/src/lib.rs b/raphtory-itertools/src/lib.rs
new file mode 100644
index 0000000000..81f2e4d2d0
--- /dev/null
+++ b/raphtory-itertools/src/lib.rs
@@ -0,0 +1,6 @@
+pub(crate) mod merge;
+pub(crate) mod merge_impl;
+mod take;
+
+pub use merge::{FastMerge, FastMergeExt};
+pub use take::{ReTake, TakeExt};
diff --git a/raphtory-itertools/src/merge.rs b/raphtory-itertools/src/merge.rs
new file mode 100644
index 0000000000..f1b54cb614
--- /dev/null
+++ b/raphtory-itertools/src/merge.rs
@@ -0,0 +1,375 @@
+use crate::merge_impl::{KMergeBy, MergeBy, MergeByGe, MergeByLt, MergeByRev, MergePredicate};
+use std::iter::{FusedIterator, Rev};
+
+pub trait FastMergeExt: Iterator<Item: IntoIterator> + Sized {
+    /// Return an iterator adaptor that flattens an iterator of iterators by
+    /// merging them according to the given closure. Uses tree merge for up to 8 iterators.
+    ///
+    /// The closure `first` is called with two elements *a*, *b* and should
+    /// return `true` if *a* is ordered before *b*.
+    ///
+    /// If all base iterators are sorted according to `first`, the result is
+    /// sorted.
+    ///
+    /// Iterator element type is `Self::Item`.
+    fn fast_merge_by<
+        F: FnMut(&<Self::Item as IntoIterator>::Item, &<Self::Item as IntoIterator>::Item) -> bool
+            + Clone,
+    >(
+        self,
+        cmp_fn: F,
+    ) -> FastMerge<<Self::Item as IntoIterator>::IntoIter, F> {
+        FastMerge::new(self.map(|i| i.into_iter()), cmp_fn)
+    }
+
+    /// Return an iterator adaptor that flattens an iterator of iterators by
+    /// merging them in ascending order. Uses tree merge for up to 8 iterators.
+    ///
+    /// If all base iterators are sorted (ascending), the result is sorted.
+    ///
+    /// Iterator element type is `Self::Item`.
+    fn fast_merge(self) -> FastMerge<<Self::Item as IntoIterator>::IntoIter, MergeByLt>
+    where
+        <Self::Item as IntoIterator>::Item: Ord,
+    {
+        FastMerge::new(self.map(|i| i.into_iter()), MergeByLt)
+    }
+
+    /// Return an iterator adaptor that flattens an iterator of iterators by
+    /// merging them in reverse according to the given closure. Uses tree merge for up to 8 iterators.
+    ///
+    /// The closure `first` is called with two elements *a*, *b* and should
+    /// return `true` if *a* is ordered before *b*.
+    ///
+    /// If all base iterators are sorted ascending according to `first`, the result is
+    /// sorted descending according to `first`.
+    ///
+    /// Iterator element type is `Self::Item`.
+    fn fast_merge_by_rev<
+        F: FnMut(&<Self::Item as IntoIterator>::Item, &<Self::Item as IntoIterator>::Item) -> bool
+            + Clone,
+    >(
+        self,
+        first: F,
+    ) -> FastMerge<Rev<<Self::Item as IntoIterator>::IntoIter>, MergeByRev<F>>
+    where
+        <Self::Item as IntoIterator>::IntoIter: DoubleEndedIterator,
+    {
+        FastMerge::new(self.map(|iter| iter.into_iter().rev()), MergeByRev(first))
+    }
+
+    /// Return an iterator adaptor that flattens an iterator of iterators by
+    /// merging and reversing them. Uses tree merge for up to 8 iterators. Uses tree merge for up to 8 iterators.
+    ///
+    /// If all base iterators are sorted ascending, the result is sorted descending.
+    ///
+    /// Iterator element type is `Self::Item`.
+    fn fast_merge_rev(self) -> FastMerge<Rev<<Self::Item as IntoIterator>::IntoIter>, MergeByGe>
+    where
+        <Self::Item as IntoIterator>::Item: Ord,
+        <Self::Item as IntoIterator>::IntoIter: DoubleEndedIterator,
+    {
+        FastMerge::new(self.map(|iter| iter.into_iter().rev()), MergeByGe)
+    }
+}
+
+impl<I: Iterator<Item: IntoIterator>> FastMergeExt for I {}
+
+#[must_use = "this iterator adaptor is not lazy but does nearly nothing unless consumed"]
+pub enum FastMerge<I: Iterator, F: MergePredicate<I::Item>> {
+    Zero,
+    One(I),
+    Two(MergeBy<I, I, F>),
+    Three(MergeBy<MergeBy<I, I, F>, I, F>),
+    Four(MergeBy<MergeBy<I, I, F>, MergeBy<I, I, F>, F>),
+    Five(MergeBy<MergeBy<MergeBy<I, I, F>, MergeBy<I, I, F>, F>, I, F>),
+    Six(MergeBy<MergeBy<MergeBy<I, I, F>, MergeBy<I, I, F>, F>, MergeBy<I, I, F>, F>),
+    Seven(
+        MergeBy<MergeBy<MergeBy<I, I, F>, MergeBy<I, I, F>, F>, MergeBy<MergeBy<I, I, F>, I, F>, F>,
+    ),
+    Eight(
+        MergeBy<
+            MergeBy<MergeBy<I, I, F>, MergeBy<I, I, F>, F>,
+            MergeBy<MergeBy<I, I, F>, MergeBy<I, I, F>, F>,
+            F,
+        >,
+    ),
+    Many(KMergeBy<I, F>),
+}
+
+impl<I: Iterator, P: MergePredicate<I::Item> + Clone> FastMerge<I, P> {
+    pub(crate) fn new(mut iters: impl Iterator<Item = I>, predicate: P) -> Self {
+        let (lower, _) = iters.size_hint();
+        if lower > 8 {
+            let mut kmerge = KMergeBy::new(lower, predicate);
+            for iter in iters {
+                kmerge.push(iter);
+            }
+            kmerge.heapify();
+            return Self::Many(kmerge);
+        }
+        match iters.next() {
+            None => return Self::Zero,
+            Some(iter1) => match iters.next() {
+                None => Self::One(iter1),
+                Some(iter2) => match iters.next() {
+                    None => Self::Two(MergeBy::new(iter1, iter2, predicate)),
+                    Some(iter3) => match iters.next() {
+                        None => Self::Three(MergeBy::new(
+                            MergeBy::new(iter1, iter2, predicate.clone()),
+                            iter3,
+                            predicate,
+                        )),
+                        Some(iter4) => match iters.next() {
+                            None => Self::Four(MergeBy::new(
+                                MergeBy::new(iter1, iter2, predicate.clone()),
+                                MergeBy::new(iter3, iter4, predicate.clone()),
+                                predicate,
+                            )),
+                            Some(iter5) => match iters.next() {
+                                None => Self::Five(MergeBy::new(
+                                    MergeBy::new(
+                                        MergeBy::new(iter1, iter2, predicate.clone()),
+                                        MergeBy::new(iter3, iter4, predicate.clone()),
+                                        predicate.clone(),
+                                    ),
+                                    iter5,
+                                    predicate,
+                                )),
+                                Some(iter6) => match iters.next() {
+                                    None => Self::Six(MergeBy::new(
+                                        MergeBy::new(
+                                            MergeBy::new(iter1, iter2, predicate.clone()),
+                                            MergeBy::new(iter3, iter4, predicate.clone()),
+                                            predicate.clone(),
+                                        ),
+                                        MergeBy::new(iter5, iter6, predicate.clone()),
+                                        predicate,
+                                    )),
+                                    Some(iter7) => match iters.next() {
+                                        None => Self::Seven(MergeBy::new(
+                                            MergeBy::new(
+                                                MergeBy::new(iter1, iter2, predicate.clone()),
+                                                MergeBy::new(iter3, iter4, predicate.clone()),
+                                                predicate.clone(),
+                                            ),
+                                            MergeBy::new(
+                                                MergeBy::new(iter5, iter6, predicate.clone()),
+                                                iter7,
+                                                predicate.clone(),
+                                            ),
+                                            predicate.clone(),
+                                        )),
+                                        Some(iter8) => match iters.next() {
+                                            None => Self::Eight(MergeBy::new(
+                                                MergeBy::new(
+                                                    MergeBy::new(iter1, iter2, predicate.clone()),
+                                                    MergeBy::new(iter3, iter4, predicate.clone()),
+                                                    predicate.clone(),
+                                                ),
+                                                MergeBy::new(
+                                                    MergeBy::new(iter5, iter6, predicate.clone()),
+                                                    MergeBy::new(iter7, iter8, predicate.clone()),
+                                                    predicate.clone(),
+                                                ),
+                                                predicate.clone(),
+                                            )),
+                                            Some(iter9) => {
+                                                let mut kmerge = KMergeBy::new(9, predicate);
+                                                kmerge.push(iter1);
+                                                kmerge.push(iter2);
+                                                kmerge.push(iter3);
+                                                kmerge.push(iter4);
+                                                kmerge.push(iter5);
+                                                kmerge.push(iter6);
+                                                kmerge.push(iter7);
+                                                kmerge.push(iter8);
+                                                kmerge.push(iter9);
+                                                for iter in iters {
+                                                    kmerge.push(iter);
+                                                }
+                                                kmerge.heapify();
+                                                Self::Many(kmerge)
+                                            }
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        }
+    }
+}
+
+impl<I: Iterator, P: MergePredicate<I::Item>> Iterator for FastMerge<I, P> {
+    type Item = I::Item;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self {
+            FastMerge::Zero => None,
+            FastMerge::One(iter) => iter.next(),
+            FastMerge::Two(iter) => iter.next(),
+            FastMerge::Three(iter) => iter.next(),
+            FastMerge::Four(iter) => iter.next(),
+            FastMerge::Five(iter) => iter.next(),
+            FastMerge::Six(iter) => iter.next(),
+            FastMerge::Seven(iter) => iter.next(),
+            FastMerge::Eight(iter) => iter.next(),
+            FastMerge::Many(iter) => iter.next(),
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        match self {
+            FastMerge::Zero => (0, Some(0)),
+            FastMerge::One(iter) => iter.size_hint(),
+            FastMerge::Two(iter) => iter.size_hint(),
+            FastMerge::Three(iter) => iter.size_hint(),
+            FastMerge::Four(iter) => iter.size_hint(),
+            FastMerge::Five(iter) => iter.size_hint(),
+            FastMerge::Six(iter) => iter.size_hint(),
+            FastMerge::Seven(iter) => iter.size_hint(),
+            FastMerge::Eight(iter) => iter.size_hint(),
+            FastMerge::Many(iter) => iter.size_hint(),
+        }
+    }
+
+    fn count(self) -> usize
+    where
+        Self: Sized,
+    {
+        match self {
+            FastMerge::Zero => 0,
+            FastMerge::One(iter) => iter.count(),
+            FastMerge::Two(iter) => iter.count(),
+            FastMerge::Three(iter) => iter.count(),
+            FastMerge::Four(iter) => iter.count(),
+            FastMerge::Five(iter) => iter.count(),
+            FastMerge::Six(iter) => iter.count(),
+            FastMerge::Seven(iter) => iter.count(),
+            FastMerge::Eight(iter) => iter.count(),
+            FastMerge::Many(iter) => iter.count(),
+        }
+    }
+
+    fn nth(&mut self, n: usize) -> Option<Self::Item> {
+        match self {
+            FastMerge::Zero => None,
+            FastMerge::One(iter) => iter.nth(n),
+            FastMerge::Two(iter) => iter.nth(n),
+            FastMerge::Three(iter) => iter.nth(n),
+            FastMerge::Four(iter) => iter.nth(n),
+            FastMerge::Five(iter) => iter.nth(n),
+            FastMerge::Six(iter) => iter.nth(n),
+            FastMerge::Seven(iter) => iter.nth(n),
+            FastMerge::Eight(iter) => iter.nth(n),
+            FastMerge::Many(iter) => iter.nth(n),
+        }
+    }
+
+    fn fold<B, F>(self, init: B, f: F) -> B
+    where
+        Self: Sized,
+        F: FnMut(B, Self::Item) -> B,
+    {
+        match self {
+            FastMerge::Zero => init,
+            FastMerge::One(iter) => iter.fold(init, f),
+            FastMerge::Two(iter) => iter.fold(init, f),
+            FastMerge::Three(iter) => iter.fold(init, f),
+            FastMerge::Four(iter) => iter.fold(init, f),
+            FastMerge::Five(iter) => iter.fold(init, f),
+            FastMerge::Six(iter) => iter.fold(init, f),
+            FastMerge::Seven(iter) => iter.fold(init, f),
+            FastMerge::Eight(iter) => iter.fold(init, f),
+            FastMerge::Many(iter) => iter.fold(init, f),
+        }
+    }
+}
+
+impl<I: Iterator<Item: Iterator>, F: MergePredicate<I::Item>> FusedIterator for FastMerge<I, F> {}
+
+#[cfg(test)]
+mod tests {
+    use crate::merge::FastMergeExt;
+    use proptest::{arbitrary::any, prelude::*, proptest};
+
+    #[test]
+    fn test_merge() {
+        proptest!(|(input in any::<Vec<Vec<usize>>>().prop_map(|mut input| {
+                        for inner in input.iter_mut() {
+                inner.sort();
+            }
+            input
+        }))| {
+            let mut expected: Vec<_> = input.iter().flatten().copied().collect();
+            expected.sort();
+            let actual: Vec<_> = input.into_iter().fast_merge().collect();
+
+            assert_eq!(actual, expected);
+
+        })
+    }
+
+    #[test]
+    fn test_reverse() {
+        proptest!(|(input in any::<Vec<Vec<usize>>>().prop_map(|mut input| {
+                        for inner in input.iter_mut() {
+                inner.sort();
+            }
+            input
+        }))| {
+            let mut expected: Vec<_> = input.iter().flatten().copied().collect();
+            expected.sort();
+            expected.reverse();
+            let actual: Vec<_> = input.into_iter().fast_merge_rev().collect();
+
+            assert_eq!(actual, expected);
+
+        })
+    }
+
+    #[test]
+    fn test_custom_merge_fn() {
+        proptest!(|(input in any::<Vec<Vec<usize>>>().prop_map(|mut input| {
+                        for inner in input.iter_mut() {
+                inner.sort();
+            }
+            input
+        }))| {
+            let mut expected: Vec<_> = input.iter().flatten().copied().collect();
+            expected.sort();
+            let actual: Vec<_> = input.into_iter().fast_merge_by(|a, b| a < b).collect();
+
+            assert_eq!(actual, expected);
+
+        })
+    }
+
+    #[test]
+    fn test_custom_merge_fn_rev() {
+        proptest!(|(input in any::<Vec<Vec<usize>>>().prop_map(|mut input| {
+                        for inner in input.iter_mut() {
+                inner.sort();
+            }
+            input
+        }))| {
+            let mut expected: Vec<_> = input.iter().flatten().copied().collect();
+            expected.sort();
+            expected.reverse();
+            let actual: Vec<_> = input.into_iter().fast_merge_by_rev(|a, b| a < b).collect();
+
+            assert_eq!(actual, expected);
+
+        })
+    }
+
+    #[test]
+    fn test_mostly_empty() {
+        let input = [vec![], vec![], vec![], vec![], vec![0usize]];
+        let res: Vec<_> = input.into_iter().fast_merge().collect();
+        assert_eq!(res, [0]);
+    }
+}
diff --git a/raphtory-itertools/src/merge_impl.rs b/raphtory-itertools/src/merge_impl.rs
new file mode 100644
index 0000000000..311026add5
--- /dev/null
+++ b/raphtory-itertools/src/merge_impl.rs
@@ -0,0 +1,399 @@
+// Notice: Adapted from Itertools: https://github.com/rust-itertools/itertools
+//
+// Copyright (c) 2015
+//
+// Permission is hereby granted, free of charge, to any
+// person obtaining a copy of this software and associated
+// documentation files (the "Software"), to deal in the
+// Software without restriction, including without
+// limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of
+// the Software, and to permit persons to whom the Software
+// is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice
+// shall be included in all copies or substantial portions
+// of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+// IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+use itertools::{put_back, PutBack};
+use std::{fmt, fmt::Formatter, iter::FusedIterator, mem::replace};
+
+/// `SizeHint` is the return type of `Iterator::size_hint()`.
+pub type SizeHint = (usize, Option<usize>);
+
+/// Add `SizeHint` correctly.
+#[inline]
+pub fn size_hint_add(a: SizeHint, b: SizeHint) -> SizeHint {
+    let min = a.0.saturating_add(b.0);
+    let max = match (a.1, b.1) {
+        (Some(x), Some(y)) => x.checked_add(y),
+        _ => None,
+    };
+
+    (min, max)
+}
+
+/// Add `x` correctly to a `SizeHint`.
+#[inline]
+pub fn size_hint_add_scalar(sh: SizeHint, x: usize) -> SizeHint {
+    let (mut low, mut hi) = sh;
+    low = low.saturating_add(x);
+    hi = hi.and_then(|elt| elt.checked_add(x));
+    (low, hi)
+}
+
+/// Head element and Tail iterator pair
+///
+/// `PartialEq`, `Eq`, `PartialOrd` and `Ord` are implemented by comparing sequences based on
+/// first items (which are guaranteed to exist).
+///
+/// The meanings of `PartialOrd` and `Ord` are reversed so as to turn the heap used in
+/// `KMerge` into a min-heap.
+#[derive(Debug)]
+struct HeadTail<I>
+where
+    I: Iterator,
+{
+    head: I::Item,
+    tail: I,
+}
+
+impl<I> HeadTail<I>
+where
+    I: Iterator,
+{
+    /// Constructs a `HeadTail` from an `Iterator`. Returns `None` if the `Iterator` is empty.
+    fn new(mut it: I) -> Option<Self> {
+        let head = it.next();
+        head.map(|h| Self { head: h, tail: it })
+    }
+
+    /// Get the next element and update `head`, returning the old head in `Some`.
+    ///
+    /// Returns `None` when the tail is exhausted (only `head` then remains).
+    fn next(&mut self) -> Option<I::Item> {
+        if let Some(next) = self.tail.next() {
+            Some(replace(&mut self.head, next))
+        } else {
+            None
+        }
+    }
+
+    /// Hints at the size of the sequence, same as the `Iterator` method.
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        size_hint_add_scalar(self.tail.size_hint(), 1)
+    }
+}
+
+/// Make `data` a heap (min-heap w.r.t the sorting).
+fn heapify<T, S>(data: &mut [T], mut less_than: S)
+where
+    S: FnMut(&T, &T) -> bool,
+{
+    for i in (0..data.len() / 2).rev() {
+        sift_down(data, i, &mut less_than);
+    }
+}
+
+/// Sift down element at `index` (`heap` is a min-heap wrt the ordering)
+fn sift_down<T, S>(heap: &mut [T], index: usize, mut less_than: S)
+where
+    S: FnMut(&T, &T) -> bool,
+{
+    debug_assert!(index <= heap.len());
+    let mut pos = index;
+    let mut child = 2 * pos + 1;
+    // Require the right child to be present
+    // This allows to find the index of the smallest child without a branch
+    // that wouldn't be predicted if present
+    while child + 1 < heap.len() {
+        // pick the smaller of the two children
+        // use arithmetic to avoid an unpredictable branch
+        child += less_than(&heap[child + 1], &heap[child]) as usize;
+
+        // sift down is done if we are already in order
+        if !less_than(&heap[child], &heap[pos]) {
+            return;
+        }
+        heap.swap(pos, child);
+        pos = child;
+        child = 2 * pos + 1;
+    }
+    // Check if the last (left) child was an only child
+    // if it is then it has to be compared with the parent
+    if child + 1 == heap.len() && less_than(&heap[child], &heap[pos]) {
+        heap.swap(pos, child);
+    }
+}
+
+pub trait MergePredicate<T> {
+    fn merge_pred(&mut self, a: &T, b: &T) -> bool;
+}
+
+#[derive(Clone, Debug)]
+pub struct MergeByLt;
+
+impl<T: PartialOrd> MergePredicate<T> for MergeByLt {
+    fn merge_pred(&mut self, a: &T, b: &T) -> bool {
+        a < b
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct MergeByGe;
+
+impl<T: PartialOrd> MergePredicate<T> for MergeByGe {
+    fn merge_pred(&mut self, a: &T, b: &T) -> bool {
+        a >= b
+    }
+}
+
+impl<T, F: FnMut(&T, &T) -> bool> MergePredicate<T> for F {
+    fn merge_pred(&mut self, a: &T, b: &T) -> bool {
+        self(a, b)
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct MergeByRev<F>(pub F);
+
+impl<T, F: MergePredicate<T>> MergePredicate<T> for MergeByRev<F> {
+    fn merge_pred(&mut self, a: &T, b: &T) -> bool {
+        self.0.merge_pred(b, a)
+    }
+}
+
+/// An iterator adaptor that merges an abitrary number of base iterators
+/// according to an ordering function.
+///
+/// Iterator element type is `I::Item`.
+///
+/// See [`.kmerge_by()`](crate::Itertools::kmerge_by) for more
+/// information.
+#[must_use = "this iterator adaptor is not lazy but does nearly nothing unless consumed"]
+pub struct KMergeBy<I, F>
+where
+    I: Iterator,
+{
+    heap: Vec<HeadTail<I>>,
+    cmp_fn: F,
+}
+
+impl<I: Iterator, F: MergePredicate<I::Item>> KMergeBy<I, F> {
+    pub(crate) fn new(capacity: usize, cmp_fn: F) -> Self {
+        let heap = Vec::with_capacity(capacity);
+        Self { heap, cmp_fn }
+    }
+
+    /// Push a new iterator into this kmerge.
+    /// Does not preserve the heap property and should only be used when constructing the iterator!
+    /// Call `self.heapify()` when done!
+    pub(crate) fn push(&mut self, iter: I) {
+        if let Some(new) = HeadTail::new(iter) {
+            self.heap.push(new);
+        }
+    }
+
+    /// Call when done constructing the iterator to finalize the heap
+    pub(crate) fn heapify(&mut self) {
+        heapify(&mut self.heap, |a, b| {
+            self.cmp_fn.merge_pred(&a.head, &b.head)
+        });
+    }
+}
+
+impl<I, F> fmt::Debug for KMergeBy<I, F>
+where
+    I: Iterator + fmt::Debug,
+    I::Item: fmt::Debug,
+{
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        f.debug_struct("KMergeBy")
+            .field("heap", &self.heap)
+            .finish()
+    }
+}
+
+impl<I, F> Iterator for KMergeBy<I, F>
+where
+    I: Iterator,
+    F: MergePredicate<I::Item>,
+{
+    type Item = I::Item;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.heap.is_empty() {
+            return None;
+        }
+        let result = if let Some(next) = self.heap[0].next() {
+            next
+        } else {
+            self.heap.swap_remove(0).head
+        };
+        let less_than = &mut self.cmp_fn;
+        sift_down(&mut self.heap, 0, |a, b| {
+            less_than.merge_pred(&a.head, &b.head)
+        });
+        Some(result)
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.heap
+            .iter()
+            .map(|i| i.size_hint())
+            .reduce(size_hint_add)
+            .unwrap_or((0, Some(0)))
+    }
+}
+
+impl<I, F> FusedIterator for KMergeBy<I, F>
+where
+    I: Iterator,
+    F: MergePredicate<I::Item>,
+{
+}
+
+/// An iterator adaptor that merges the two base iterators in ascending order.
+/// If both base iterators are sorted (ascending), the result is sorted.
+///
+/// Iterator element type is `I::Item`.
+///
+/// See [`.merge_by()`](crate::Itertools::merge_by) for more information.
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+pub struct MergeBy<I: Iterator, J: Iterator, F> {
+    pub(crate) left: PutBack<I>,
+    pub(crate) right: PutBack<J>,
+    pub(crate) cmp_fn: F,
+}
+
+impl<I: Iterator, J: Iterator, F> MergeBy<I, J, F> {
+    pub(crate) fn new(left: I, right: J, cmp_fn: F) -> Self {
+        let left = put_back(left);
+        let right = put_back(right);
+        Self {
+            left,
+            right,
+            cmp_fn,
+        }
+    }
+
+    /// Take the iterators back out.
+    ///
+    /// Warning: discards the head in the `PutBack` and should only be used before actually iterating over the struct!
+    pub fn into_inner(self) -> (I, J, F) {
+        let (_, left) = self.left.into_parts();
+        let (_, right) = self.right.into_parts();
+        (left, right, self.cmp_fn)
+    }
+}
+
+impl<I, J, F> Iterator for MergeBy<I, J, F>
+where
+    I: Iterator,
+    J: Iterator<Item = I::Item>,
+    F: MergePredicate<I::Item>,
+{
+    type Item = I::Item;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match (self.left.next(), self.right.next()) {
+            (None, None) => None,
+            (Some(left), None) => Some(left),
+            (None, Some(right)) => Some(right),
+            (Some(left), Some(right)) => {
+                if self.cmp_fn.merge_pred(&left, &right) {
+                    self.right.put_back(right);
+                    Some(left)
+                } else {
+                    self.left.put_back(left);
+                    Some(right)
+                }
+            }
+        }
+    }
+
+    fn fold<B, G>(mut self, init: B, mut f: G) -> B
+    where
+        Self: Sized,
+        G: FnMut(B, Self::Item) -> B,
+    {
+        let mut acc = init;
+        let mut left = self.left.next();
+        let mut right = self.right.next();
+
+        loop {
+            match (left, right) {
+                (Some(l), Some(r)) => {
+                    if self.cmp_fn.merge_pred(&l, &r) {
+                        acc = f(acc, l);
+                        left = self.left.next();
+                        right = Some(r);
+                    } else {
+                        acc = f(acc, r);
+                        left = Some(l);
+                        right = self.right.next();
+                    }
+                }
+                (Some(l), None) => {
+                    self.left.put_back(l);
+                    acc = self.left.fold(acc, |acc, x| f(acc, x));
+                    break;
+                }
+                (None, Some(r)) => {
+                    self.right.put_back(r);
+                    acc = self.right.fold(acc, |acc, x| f(acc, x));
+                    break;
+                }
+                (None, None) => {
+                    break;
+                }
+            }
+        }
+
+        acc
+    }
+
+    fn size_hint(&self) -> SizeHint {
+        size_hint_add(self.left.size_hint(), self.right.size_hint())
+    }
+
+    fn nth(&mut self, mut n: usize) -> Option<Self::Item> {
+        loop {
+            if n == 0 {
+                break self.next();
+            }
+            n -= 1;
+            match (self.left.next(), self.right.next()) {
+                (None, None) => break None,
+                (Some(_left), None) => break self.left.nth(n),
+                (None, Some(_right)) => break self.right.nth(n),
+                (Some(left), Some(right)) => {
+                    if self.cmp_fn.merge_pred(&left, &right) {
+                        self.right.put_back(right);
+                    } else {
+                        self.left.put_back(left);
+                    }
+                }
+            }
+        }
+    }
+}
+
+impl<I, J, F> FusedIterator for MergeBy<I, J, F>
+where
+    I: FusedIterator,
+    J: FusedIterator<Item = I::Item>,
+    F: MergePredicate<I::Item>,
+{
+}
diff --git a/raphtory-itertools/src/take.rs b/raphtory-itertools/src/take.rs
new file mode 100644
index 0000000000..06d4e6ecdf
--- /dev/null
+++ b/raphtory-itertools/src/take.rs
@@ -0,0 +1,142 @@
+use std::{cmp, iter::FusedIterator};
+
+/// An iterator that only iterates over the first `n` iterations of `iter`.
+///
+/// This `struct` is created by the [`takeable`] method on [`Iterator`]. See its
+/// documentation for more.
+///
+/// [`take`]: Iterator::take
+/// [`Iterator`]: trait.Iterator.html
+#[derive(Clone, Debug)]
+#[must_use = "iterators are lazy and do nothing unless consumed"]
+pub struct ReTake<I> {
+    iter: I,
+    n: usize,
+}
+
+pub trait TakeExt: Sized {
+    fn take_updatable(self, n: usize) -> ReTake<Self>;
+}
+
+impl<I: Iterator> TakeExt for I {
+    fn take_updatable(self, n: usize) -> ReTake<Self> {
+        ReTake { iter: self, n }
+    }
+}
+
+impl<I: Iterator> ReTake<I> {
+    /// Take the first n elements of the iterator by updating the current take
+    pub fn take_inplace(&mut self, n: usize) {
+        self.n = self.n.min(n);
+    }
+
+    /// Advance the iterator by n elements
+    pub fn advance_by(&mut self, n: usize) {
+        if let Some(to_skip) = n.min(self.n).checked_sub(1) {
+            self.iter.nth(to_skip);
+        }
+        self.n = self.n.saturating_sub(n);
+    }
+}
+
+impl<I> Iterator for ReTake<I>
+where
+    I: Iterator,
+{
+    type Item = <I as Iterator>::Item;
+
+    #[inline]
+    fn next(&mut self) -> Option<<I as Iterator>::Item> {
+        if self.n != 0 {
+            self.n -= 1;
+            self.iter.next()
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    fn nth(&mut self, n: usize) -> Option<I::Item> {
+        if self.n > n {
+            self.n -= n + 1;
+            self.iter.nth(n)
+        } else {
+            if self.n > 0 {
+                self.iter.nth(self.n - 1);
+                self.n = 0;
+            }
+            None
+        }
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        if self.n == 0 {
+            return (0, Some(0));
+        }
+
+        let (lower, upper) = self.iter.size_hint();
+
+        let lower = cmp::min(lower, self.n);
+
+        let upper = match upper {
+            Some(x) if x < self.n => Some(x),
+            _ => Some(self.n),
+        };
+
+        (lower, upper)
+    }
+}
+
+impl<I> DoubleEndedIterator for ReTake<I>
+where
+    I: DoubleEndedIterator + ExactSizeIterator,
+{
+    #[inline]
+    fn next_back(&mut self) -> Option<Self::Item> {
+        if self.n == 0 {
+            None
+        } else {
+            let n = self.n;
+            self.n -= 1;
+            self.iter.nth_back(self.iter.len().saturating_sub(n))
+        }
+    }
+
+    #[inline]
+    fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
+        let len = self.iter.len();
+        if self.n > n {
+            let m = len.saturating_sub(self.n) + n;
+            self.n -= n + 1;
+            self.iter.nth_back(m)
+        } else {
+            if len > 0 {
+                self.iter.nth_back(len - 1);
+            }
+            None
+        }
+    }
+
+    #[inline]
+    fn rfold<Acc, Fold>(mut self, init: Acc, fold: Fold) -> Acc
+    where
+        Self: Sized,
+        Fold: FnMut(Acc, Self::Item) -> Acc,
+    {
+        if self.n == 0 {
+            init
+        } else {
+            let len = self.iter.len();
+            if len > self.n && self.iter.nth_back(len - self.n - 1).is_none() {
+                init
+            } else {
+                self.iter.rfold(init, fold)
+            }
+        }
+    }
+}
+
+impl<I> ExactSizeIterator for ReTake<I> where I: ExactSizeIterator {}
+
+impl<I> FusedIterator for ReTake<I> where I: FusedIterator {}
diff --git a/raphtory-server/Cargo.toml b/raphtory-server/Cargo.toml
new file mode 100644
index 0000000000..8015995507
--- /dev/null
+++ b/raphtory-server/Cargo.toml
@@ -0,0 +1,13 @@
+[package]
+name = "raphtory-server"
+version.workspace = true
+edition.workspace = true
+
+[[bin]]
+name = "raphtory-server"
+path = "src/main.rs"
+
+[dependencies]
+raphtory-graphql = { workspace = true }
+auth = { workspace = true }
+tokio = { workspace = true }
diff --git a/raphtory-graphql/src/main.rs b/raphtory-server/src/main.rs
similarity index 87%
rename from raphtory-graphql/src/main.rs
rename to raphtory-server/src/main.rs
index 9a15f7580b..733c411eb4 100644
--- a/raphtory-graphql/src/main.rs
+++ b/raphtory-server/src/main.rs
@@ -2,5 +2,6 @@ use std::io::Result as IoResult;
 
 #[tokio::main]
 async fn main() -> IoResult<()> {
+    auth::init();
     raphtory_graphql::cli::cli().await
 }
diff --git a/raphtory-storage/Cargo.toml b/raphtory-storage/Cargo.toml
index 1435f1e309..64e96359bb 100644
--- a/raphtory-storage/Cargo.toml
+++ b/raphtory-storage/Cargo.toml
@@ -14,22 +14,22 @@ edition.workspace = true
 
 [dependencies]
 raphtory-api = { workspace = true }
+raphtory-api-macros = { workspace = true }
 raphtory-core = { workspace = true }
+storage.workspace = true
+db4-graph.workspace = true
+parking_lot.workspace = true
 rayon = { workspace = true }
 iter-enum = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 itertools = { workspace = true }
 thiserror = { workspace = true }
-pometry-storage = { workspace = true, optional = true }
 bigdecimal = { workspace = true, optional = true }
 num-traits = { workspace = true, optional = true }
-parking_lot = { workspace = true }
-arrow-array = { workspace = true, optional = true }
-arrow-schema = { workspace = true, optional = true }
+arrow-array = { workspace = true }
+arrow-schema = { workspace = true }
 
 [dev-dependencies]
 proptest = { workspace = true }
 tempfile = { workspace = true }
 
-[features]
-storage = ["raphtory-api/storage", "dep:pometry-storage", "dep:bigdecimal", "dep:num-traits", "dep:arrow-array", "dep:arrow-schema"]
diff --git a/raphtory-storage/build.rs b/raphtory-storage/build.rs
new file mode 100644
index 0000000000..2500803898
--- /dev/null
+++ b/raphtory-storage/build.rs
@@ -0,0 +1,10 @@
+use std::io::Result;
+
+fn main() -> Result<()> {
+    println!("cargo::rustc-check-cfg=cfg(has_debug_symbols)");
+    if let Ok("true" | "1" | "2") = std::env::var("DEBUG").as_deref() {
+        println!("cargo::rustc-cfg=has_debug_symbols");
+    }
+
+    Ok(())
+}
diff --git a/raphtory-storage/src/core_ops.rs b/raphtory-storage/src/core_ops.rs
index c1ac36621b..bf1436cf27 100644
--- a/raphtory-storage/src/core_ops.rs
+++ b/raphtory-storage/src/core_ops.rs
@@ -7,19 +7,20 @@ use crate::graph::{
 use raphtory_api::{
     core::{
         entities::{
-            properties::{meta::Meta, prop::Prop},
-            GidType, LayerIds, EID, GID, VID,
+            properties::{
+                meta::{Meta, STATIC_GRAPH_LAYER_ID},
+                prop::Prop,
+            },
+            GidType, LayerId, LayerIds, EID, GID, VID,
         },
         storage::arc_str::ArcStr,
     },
     inherit::Base,
-    iter::{BoxedIter, BoxedLIter},
-};
-use raphtory_core::entities::{nodes::node_ref::NodeRef, properties::graph_meta::GraphMeta};
-use std::{
-    iter,
-    sync::{atomic::Ordering, Arc},
+    iter::{BoxedIter, BoxedLIter, IntoDynBoxed},
 };
+use raphtory_core::entities::nodes::node_ref::NodeRef;
+use std::{iter, sync::Arc};
+use storage::resolver::GIDResolverOps;
 
 /// Check if two Graph views point at the same underlying storage
 pub fn is_view_compatible(g1: &impl CoreGraphOps, g2: &impl CoreGraphOps) -> bool {
@@ -33,42 +34,36 @@ pub trait CoreGraphOps: Send + Sync {
             GraphStorage::Mem(LockedGraph { graph, .. }) | GraphStorage::Unlocked(graph) => {
                 graph.logical_to_physical.dtype()
             }
-            #[cfg(feature = "storage")]
-            GraphStorage::Disk(storage) => Some(storage.inner().id_type()),
         }
     }
 
-    fn num_shards(&self) -> usize {
-        match self.core_graph() {
-            GraphStorage::Mem(LockedGraph { graph, .. }) | GraphStorage::Unlocked(graph) => {
-                graph.storage.num_shards()
-            }
-            #[cfg(feature = "storage")]
-            GraphStorage::Disk(_) => 1,
-        }
-    }
+    // fn num_shards(&self) -> usize {
+    //     match self.core_graph() {
+    //         GraphStorage::Mem(LockedGraph { graph, .. }) | GraphStorage::Unlocked(graph) => {
+    //             graph.storage.num_shards()
+    //         }
+    //     }
+    // }
 
     /// get the current sequence id without incrementing the counter
     fn read_event_id(&self) -> usize {
         match self.core_graph() {
-            GraphStorage::Unlocked(graph) | GraphStorage::Mem(LockedGraph { graph, .. }) => {
-                graph.event_counter.load(Ordering::Relaxed)
+            GraphStorage::Mem(LockedGraph { graph, .. }) | GraphStorage::Unlocked(graph) => {
+                graph.storage().read_event_id()
             }
-            #[cfg(feature = "storage")]
-            GraphStorage::Disk(storage) => storage.inner.count_temporal_edges(),
         }
     }
 
     /// get the number of nodes in the main graph
     #[inline]
-    fn unfiltered_num_nodes(&self) -> usize {
-        self.core_graph().unfiltered_num_nodes()
+    fn unfiltered_num_nodes(&self, layer_ids: &LayerIds) -> usize {
+        self.core_graph().unfiltered_num_nodes(layer_ids)
     }
 
     /// get the number of edges in the main graph
     #[inline]
-    fn unfiltered_num_edges(&self) -> usize {
-        self.core_graph().unfiltered_num_edges()
+    fn unfiltered_num_edges(&self, layer_ids: &LayerIds) -> usize {
+        self.core_graph().unfiltered_num_edges(layer_ids)
     }
 
     /// get the number of layers in the main graph
@@ -78,12 +73,12 @@ pub trait CoreGraphOps: Send + Sync {
     }
 
     /// Return the id of the single layer if `layer_ids` reduces to a graph with a single layer, else None
-    fn single_layer(&self, layer_ids: &LayerIds) -> Option<usize> {
+    fn single_layer(&self, layer_ids: &LayerIds) -> Option<LayerId> {
         match layer_ids {
             LayerIds::None => None,
             LayerIds::All => {
                 if self.unfiltered_num_layers() == 1 {
-                    Some(0)
+                    Some(STATIC_GRAPH_LAYER_ID)
                 } else {
                     None
                 }
@@ -105,6 +100,7 @@ pub trait CoreGraphOps: Send + Sync {
     fn core_edges(&self) -> EdgesStorage {
         self.core_graph().owned_edges()
     }
+
     #[inline]
     fn core_edge(&self, eid: EID) -> EdgeStorageEntry<'_> {
         self.core_graph().edge_entry(eid)
@@ -131,22 +127,22 @@ pub trait CoreGraphOps: Send + Sync {
     }
 
     #[inline]
-    fn graph_meta(&self) -> &GraphMeta {
-        self.core_graph().graph_meta()
+    fn graph_props_meta(&self) -> &Meta {
+        self.core_graph().graph_props_meta()
     }
 
     #[inline]
-    fn get_layer_name(&self, layer_id: usize) -> ArcStr {
-        self.edge_meta().layer_meta().get_name(layer_id).clone()
+    fn get_layer_name(&self, layer_id: LayerId) -> ArcStr {
+        self.edge_meta().layer_meta().get_name(layer_id.0).clone()
     }
 
     #[inline]
-    fn get_layer_id(&self, name: &str) -> Option<usize> {
-        self.edge_meta().get_layer_id(name)
+    fn get_layer_id(&self, name: &str) -> Option<LayerId> {
+        self.edge_meta().get_layer_id(name).map(|id| id)
     }
 
     #[inline]
-    fn get_default_layer_id(&self) -> Option<usize> {
+    fn get_default_layer_id(&self) -> Option<LayerId> {
         self.edge_meta().get_default_layer_id()
     }
 
@@ -156,14 +152,14 @@ pub trait CoreGraphOps: Send + Sync {
         let layer_ids = layer_ids.clone();
         match layer_ids {
             LayerIds::None => Box::new(iter::empty()),
-            LayerIds::All => Box::new(self.edge_meta().layer_meta().get_keys().into_iter()),
+            LayerIds::All => Box::new(self.edge_meta().layer_meta().keys().into_iter()), // first layer is static graph and private
             LayerIds::One(id) => {
-                let name = self.edge_meta().layer_meta().get_name(id).clone();
+                let name = self.edge_meta().layer_meta().get_name(id.0).clone();
                 Box::new(iter::once(name))
             }
             LayerIds::Multiple(ids) => {
-                let keys = self.edge_meta().layer_meta().get_keys();
-                Box::new(ids.into_iter().map(move |id| keys[id].clone()))
+                let keys = self.edge_meta().layer_meta().all_keys();
+                Box::new(ids.into_iter().map(move |id| keys[id.0].clone()))
             }
         }
     }
@@ -184,9 +180,7 @@ pub trait CoreGraphOps: Send + Sync {
     #[inline]
     fn node_name(&self, v: VID) -> String {
         let node = self.core_node(v);
-        node.name()
-            .map(|name| name.to_string())
-            .unwrap_or_else(|| node.id().to_str().to_string())
+        node.name().as_ref().to_owned()
     }
 
     /// Returns the type of node
@@ -226,7 +220,7 @@ pub trait CoreGraphOps: Send + Sync {
     /// The property value if it exists.
     fn node_metadata(&self, v: VID, id: usize) -> Option<Prop> {
         let core_node_entry = self.core_node(v);
-        core_node_entry.prop(id)
+        core_node_entry.constant_prop_layer(STATIC_GRAPH_LAYER_ID, id)
     }
 
     /// Gets the keys of metadata of a given node
@@ -237,9 +231,8 @@ pub trait CoreGraphOps: Send + Sync {
     ///
     /// # Returns
     /// The keys of the metadata.
-    fn node_metadata_ids(&self, v: VID) -> BoxedLIter<'_, usize> {
-        let core_node_entry = self.core_node(v);
-        core_node_entry.metadata_ids()
+    fn node_metadata_ids(&self, _v: VID) -> BoxedLIter<'_, usize> {
+        self.node_meta().metadata_mapper().ids().into_dyn_boxed()
     }
 
     /// Returns a vector of all ids of temporal properties within the given node
@@ -250,9 +243,11 @@ pub trait CoreGraphOps: Send + Sync {
     ///
     /// # Returns
     /// The ids of the temporal properties
-    fn temporal_node_prop_ids(&self, v: VID) -> Box<dyn Iterator<Item = usize> + '_> {
-        let core_node_entry = self.core_node(v);
-        core_node_entry.temporal_prop_ids()
+    fn temporal_node_prop_ids(&self, _v: VID) -> Box<dyn Iterator<Item = usize> + '_> {
+        self.node_meta()
+            .temporal_prop_mapper()
+            .ids()
+            .into_dyn_boxed()
     }
 }
 
diff --git a/raphtory-storage/src/disk/graph_impl/mod.rs b/raphtory-storage/src/disk/graph_impl/mod.rs
deleted file mode 100644
index 72682ff61d..0000000000
--- a/raphtory-storage/src/disk/graph_impl/mod.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-use pometry_storage::edge::Edge;
-pub mod prop_conversion;
-
-pub type DiskEdge<'a> = Edge<'a>;
diff --git a/raphtory-storage/src/disk/graph_impl/prop_conversion.rs b/raphtory-storage/src/disk/graph_impl/prop_conversion.rs
deleted file mode 100644
index e7547054b2..0000000000
--- a/raphtory-storage/src/disk/graph_impl/prop_conversion.rs
+++ /dev/null
@@ -1,217 +0,0 @@
-use crate::{core_ops::CoreGraphOps, graph::nodes::node_storage_ops::NodeStorageOps};
-use arrow_array::{
-    builder::BooleanBuilder, ArrayRef, Decimal128Array, Float32Array, Float64Array, Int32Array,
-    Int64Array, LargeStringArray, UInt16Array, UInt32Array, UInt64Array, UInt8Array,
-};
-use arrow_schema::{DataType, Field, Schema, DECIMAL128_MAX_PRECISION};
-use itertools::Itertools;
-use num_traits::ToPrimitive;
-use pometry_storage::{
-    chunked_array::array_like::BaseArrayLike,
-    properties::{node_ts, NodePropsBuilder, Properties},
-    RAError,
-};
-use raphtory_api::core::entities::{
-    properties::{
-        meta::PropMapper,
-        prop::{Prop, PropType, PropUnwrap},
-        tprop::TPropOps,
-    },
-    VID,
-};
-use raphtory_core::utils::iter::GenLockedIter;
-use std::path::Path;
-
-pub fn make_node_properties_from_graph<G: CoreGraphOps>(
-    graph: &G,
-    graph_dir: impl AsRef<Path>,
-) -> Result<Properties<VID>, RAError> {
-    let graph_dir = graph_dir.as_ref();
-    let n = graph.unfiltered_num_nodes();
-
-    let temporal_mapper = graph.node_meta().temporal_prop_mapper();
-    let metadata_mapper = graph.node_meta().metadata_mapper();
-
-    let gs = graph.core_graph();
-
-    let temporal_prop_keys = temporal_mapper
-        .get_keys()
-        .iter()
-        .map(|s| s.to_string())
-        .collect();
-
-    let metadata_keys = metadata_mapper
-        .get_keys()
-        .iter()
-        .map(|s| s.to_string())
-        .collect();
-
-    let builder = NodePropsBuilder::new(n, graph_dir)
-        .with_timestamps(|vid| {
-            let node = gs.core_node(vid);
-            node.as_ref().temp_prop_rows().map(|(ts, _)| ts).collect()
-        })
-        .with_metadata(metadata_keys, |prop_id, prop_key| {
-            let prop_type = metadata_mapper.get_dtype(prop_id).unwrap();
-            let col = arrow_array_from_props(
-                (0..n).map(|vid| {
-                    let node = gs.core_node(VID(vid));
-                    node.prop(prop_id)
-                }),
-                prop_type,
-            );
-            col.map(|col| {
-                let dtype = col.data_type().clone();
-                (Field::new(prop_key, dtype, true), col)
-            })
-        })
-        .with_properties(temporal_prop_keys, |prop_id, prop_key, ts, offsets| {
-            let prop_type = temporal_mapper.get_dtype(prop_id).unwrap();
-            let col = arrow_array_from_props(
-                (0..n).flat_map(|vid| {
-                    let ts = node_ts(VID(vid), offsets, ts);
-                    let node = gs.core_node(VID(vid));
-                    let iter =
-                        GenLockedIter::from(node, |node| Box::new(node.tprop(prop_id).iter()));
-                    iter.merge_join_by(ts, |(t2, _), &t1| t2.cmp(t1))
-                        .map(|result| match result {
-                            itertools::EitherOrBoth::Both((_, t_prop), _) => Some(t_prop),
-                            _ => None,
-                        })
-                }),
-                prop_type,
-            );
-            col.map(|col| {
-                let dtype = col.data_type().clone();
-                (Field::new(prop_key, dtype, true), col)
-            })
-        });
-
-    let props = builder.build()?;
-    Ok(props)
-}
-
-/// Map iterator of prop values to array (returns None if all the props are None)
-pub fn arrow_array_from_props(
-    props: impl Iterator<Item = Option<Prop>>,
-    prop_type: PropType,
-) -> Option<ArrayRef> {
-    match prop_type {
-        PropType::Str => {
-            let array: LargeStringArray = props.map(|prop| prop.into_str()).collect();
-            (array.null_count() != array.len()).then_some(array.as_array_ref())
-        }
-        PropType::U8 => {
-            let array: UInt8Array = props.map(|prop| prop.into_u8()).collect();
-            (array.null_count() != array.len()).then_some(array.as_array_ref())
-        }
-        PropType::U16 => {
-            let array: UInt16Array = props.map(|prop| prop.into_u16()).collect();
-            (array.null_count() != array.len()).then_some(array.as_array_ref())
-        }
-        PropType::I32 => {
-            let array: Int32Array = props.map(|prop| prop.into_i32()).collect();
-            (array.null_count() != array.len()).then_some(array.as_array_ref())
-        }
-        PropType::I64 => {
-            let array: Int64Array = props.map(|prop| prop.into_i64()).collect();
-            (array.null_count() != array.len()).then_some(array.as_array_ref())
-        }
-        PropType::U32 => {
-            let array: UInt32Array = props.map(|prop| prop.into_u32()).collect();
-            (array.null_count() != array.len()).then_some(array.as_array_ref())
-        }
-        PropType::U64 => {
-            let array: UInt64Array = props.map(|prop| prop.into_u64()).collect();
-            (array.null_count() != array.len()).then_some(array.as_array_ref())
-        }
-        PropType::F32 => {
-            let array: Float32Array = props.map(|prop| prop.into_f32()).collect();
-            (array.null_count() != array.len()).then_some(array.as_array_ref())
-        }
-        PropType::F64 => {
-            let array: Float64Array = props.map(|prop| prop.into_f64()).collect();
-            (array.null_count() != array.len()).then_some(array.as_array_ref())
-        }
-        PropType::Bool => {
-            // direct collect requires known size for the iterator which we do not have
-            let mut builder = BooleanBuilder::new();
-            builder.extend(props.map(|prop| prop.into_bool()));
-            let array = builder.finish();
-            (array.null_count() != array.len()).then_some(array.as_array_ref())
-        }
-        PropType::Decimal { scale } => {
-            let array: Decimal128Array = props
-                .map(|prop| {
-                    prop.into_decimal().and_then(|d| {
-                        let (int, _) = d.as_bigint_and_exponent();
-                        int.to_i128()
-                    })
-                })
-                .collect();
-            (array.null_count() != array.len()).then_some(
-                array
-                    .with_precision_and_scale(DECIMAL128_MAX_PRECISION, scale as i8)
-                    .expect("valid decimal")
-                    .as_array_ref(),
-            )
-        }
-        PropType::Empty
-        | PropType::List(_)
-        | PropType::Map(_)
-        | PropType::NDTime
-        | PropType::Array(_)
-        | PropType::DTime => panic!("{prop_type:?} not supported as disk_graph property"),
-    }
-}
-
-pub fn schema_from_prop_meta(prop_map: &PropMapper) -> Schema {
-    let time_field = Field::new("time", DataType::Int64, false);
-    let mut schema = vec![time_field];
-
-    for (id, key) in prop_map.get_keys().iter().enumerate() {
-        match prop_map.get_dtype(id).unwrap() {
-            PropType::Str => {
-                schema.push(Field::new(key, DataType::LargeUtf8, true));
-            }
-            PropType::U8 => {
-                schema.push(Field::new(key, DataType::UInt8, true));
-            }
-            PropType::U16 => {
-                schema.push(Field::new(key, DataType::UInt16, true));
-            }
-            PropType::I32 => {
-                schema.push(Field::new(key, DataType::Int32, true));
-            }
-            PropType::I64 => {
-                schema.push(Field::new(key, DataType::Int64, true));
-            }
-            PropType::U32 => {
-                schema.push(Field::new(key, DataType::UInt32, true));
-            }
-            PropType::U64 => {
-                schema.push(Field::new(key, DataType::UInt64, true));
-            }
-            PropType::F32 => {
-                schema.push(Field::new(key, DataType::Float32, true));
-            }
-            PropType::F64 => {
-                schema.push(Field::new(key, DataType::Float64, true));
-            }
-            PropType::Bool => {
-                schema.push(Field::new(key, DataType::Boolean, true));
-            }
-            PropType::Decimal { scale } => {
-                schema.push(Field::new(key, DataType::Decimal128(38, scale as i8), true));
-            }
-            prop_type @ (PropType::Empty
-            | PropType::List(_)
-            | PropType::Map(_)
-            | PropType::NDTime
-            | PropType::Array(_)
-            | PropType::DTime) => panic!("{:?} not supported as disk_graph property", prop_type),
-        }
-    }
-
-    Schema::new(schema)
-}
diff --git a/raphtory-storage/src/disk/mod.rs b/raphtory-storage/src/disk/mod.rs
deleted file mode 100644
index 03aeabcfba..0000000000
--- a/raphtory-storage/src/disk/mod.rs
+++ /dev/null
@@ -1,719 +0,0 @@
-use crate::{
-    core_ops::CoreGraphOps, disk::graph_impl::prop_conversion::make_node_properties_from_graph,
-};
-use arrow_array::{ArrayRef, Float64Array, Int64Array, StructArray, UInt64Array};
-use arrow_schema::{DataType, Field};
-use pometry_storage::{
-    graph::TemporalGraph, graph_fragment::TempColGraphFragment, interop::GraphLike,
-    load::ExternalEdgeList, merge::merge_graph::merge_graphs, RAError,
-};
-use raphtory_api::core::{
-    entities::{properties::meta::Meta, Layer, LayerIds},
-    storage::timeindex::AsTime,
-};
-use raphtory_core::entities::{graph::tgraph::InvalidLayer, properties::graph_meta::GraphMeta};
-use rayon::iter::{IndexedParallelIterator, IntoParallelRefIterator, ParallelIterator};
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
-use std::{
-    fmt::{Display, Formatter},
-    path::{Path, PathBuf},
-    sync::Arc,
-};
-
-pub mod graph_impl;
-pub mod storage_interface;
-
-pub type Time = i64;
-
-pub mod prelude {
-    pub use pometry_storage::chunked_array::array_ops::*;
-}
-
-pub use pometry_storage as disk_storage;
-use pometry_storage::chunked_array::array_like::{BaseArrayLike, FromVec};
-
-#[derive(Debug)]
-pub struct ParquetLayerCols<'a> {
-    pub parquet_dir: &'a str,
-    pub layer: &'a str,
-    pub src_col: &'a str,
-    pub dst_col: &'a str,
-    pub time_col: &'a str,
-    pub exclude_edge_props: Vec<&'a str>,
-}
-
-#[derive(Clone, Debug)]
-pub struct DiskGraphStorage {
-    pub inner: Arc<TemporalGraph>,
-    graph_props: Arc<GraphMeta>,
-}
-
-impl From<TemporalGraph> for DiskGraphStorage {
-    fn from(value: TemporalGraph) -> Self {
-        Self::new(value)
-    }
-}
-
-impl Serialize for DiskGraphStorage {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        let path = self.graph_dir();
-        path.serialize(serializer)
-    }
-}
-
-impl<'de> Deserialize<'de> for DiskGraphStorage {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let path = PathBuf::deserialize(deserializer)?;
-        let graph_result = DiskGraphStorage::load_from_dir(&path).map_err(|err| {
-            serde::de::Error::custom(format!("Failed to load Diskgraph: {:?}", err))
-        })?;
-        Ok(graph_result)
-    }
-}
-
-impl Display for DiskGraphStorage {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "Diskgraph(num_nodes={}, num_temporal_edges={}",
-            self.inner.num_nodes(),
-            self.inner.count_temporal_edges()
-        )
-    }
-}
-
-impl AsRef<TemporalGraph> for DiskGraphStorage {
-    fn as_ref(&self) -> &TemporalGraph {
-        &self.inner
-    }
-}
-
-impl DiskGraphStorage {
-    pub fn inner(&self) -> &Arc<TemporalGraph> {
-        &self.inner
-    }
-
-    pub fn graph_dir(&self) -> &Path {
-        self.inner.graph_dir()
-    }
-
-    pub fn valid_layer_ids_from_names(&self, key: Layer) -> LayerIds {
-        match key {
-            Layer::All => LayerIds::All,
-            Layer::Default => LayerIds::One(0),
-            Layer::One(name) => self
-                .inner
-                .find_layer_id(&name)
-                .map(LayerIds::One)
-                .unwrap_or(LayerIds::None),
-            Layer::None => LayerIds::None,
-            Layer::Multiple(names) => {
-                let mut new_layers = names
-                    .iter()
-                    .filter_map(|name| self.inner.find_layer_id(name))
-                    .collect::<Vec<_>>();
-
-                let num_layers = self.inner.num_layers();
-                let num_new_layers = new_layers.len();
-                if num_new_layers == 0 {
-                    LayerIds::None
-                } else if num_new_layers == 1 {
-                    LayerIds::One(new_layers[0])
-                } else if num_new_layers == num_layers {
-                    LayerIds::All
-                } else {
-                    new_layers.sort_unstable();
-                    new_layers.dedup();
-                    LayerIds::Multiple(new_layers.into())
-                }
-            }
-        }
-    }
-
-    pub fn layer_ids_from_names(&self, key: Layer) -> Result<LayerIds, InvalidLayer> {
-        match key {
-            Layer::All => Ok(LayerIds::All),
-            Layer::Default => Ok(LayerIds::One(0)),
-            Layer::One(name) => {
-                let id = self
-                    .inner
-                    .find_layer_id(&name)
-                    .ok_or_else(|| InvalidLayer::new(name, self.inner.get_valid_layers()))?;
-                Ok(LayerIds::One(id))
-            }
-            Layer::None => Ok(LayerIds::None),
-            Layer::Multiple(names) => {
-                let mut new_layers = names
-                    .iter()
-                    .map(|name| {
-                        self.inner.find_layer_id(name).ok_or_else(|| {
-                            InvalidLayer::new(name.clone(), self.inner.get_valid_layers())
-                        })
-                    })
-                    .collect::<Result<Vec<_>, _>>()?;
-
-                let num_layers = self.inner.num_layers();
-                let num_new_layers = new_layers.len();
-                if num_new_layers == 0 {
-                    Ok(LayerIds::None)
-                } else if num_new_layers == 1 {
-                    Ok(LayerIds::One(new_layers[0]))
-                } else if num_new_layers == num_layers {
-                    Ok(LayerIds::All)
-                } else {
-                    new_layers.sort_unstable();
-                    new_layers.dedup();
-                    Ok(LayerIds::Multiple(new_layers.into()))
-                }
-            }
-        }
-    }
-
-    pub fn make_simple_graph(
-        graph_dir: impl AsRef<Path>,
-        edges: &[(u64, u64, i64, f64)],
-        chunk_size: usize,
-        t_props_chunk_size: usize,
-    ) -> DiskGraphStorage {
-        // unzip into 4 vectors
-        let (src, (dst, (time, weight))): (Vec<_>, (Vec<_>, (Vec<_>, Vec<_>))) = edges
-            .iter()
-            .map(|(a, b, c, d)| (*a, (*b, (*c, *d))))
-            .unzip();
-
-        let edge_lists = vec![StructArray::new(
-            vec![
-                Field::new("src", DataType::UInt64, false),
-                Field::new("dst", DataType::UInt64, false),
-                Field::new("time", DataType::Int64, false),
-                Field::new("weight", DataType::Float64, false),
-            ]
-            .into(),
-            vec![
-                UInt64Array::from_vec(src).as_array_ref(),
-                UInt64Array::from_vec(dst).as_array_ref(),
-                Int64Array::from_vec(time).as_array_ref(),
-                Float64Array::from_vec(weight).as_array_ref(),
-            ],
-            None,
-        )];
-        DiskGraphStorage::load_from_edge_lists(
-            &edge_lists,
-            chunk_size,
-            t_props_chunk_size,
-            graph_dir.as_ref(),
-            2,
-            0,
-            1,
-        )
-        .expect("failed to create graph")
-    }
-
-    /// Merge this graph with another `DiskGraph`. Note that both graphs should have nodes that are
-    /// sorted by their global ids or the resulting graph will be nonsense!
-    pub fn merge_by_sorted_gids(
-        &self,
-        other: &DiskGraphStorage,
-        new_graph_dir: impl AsRef<Path>,
-    ) -> Result<DiskGraphStorage, RAError> {
-        let graph_dir = new_graph_dir.as_ref();
-        let inner = merge_graphs(graph_dir, &self.inner, &other.inner)?;
-        Ok(DiskGraphStorage::new(inner))
-    }
-
-    pub fn new(inner_graph: TemporalGraph) -> Self {
-        let graph_meta = GraphMeta::new();
-
-        Self {
-            inner: Arc::new(inner_graph),
-            graph_props: Arc::new(graph_meta),
-        }
-    }
-
-    pub fn from_graph<T: AsTime, G: GraphLike<T> + CoreGraphOps>(
-        graph: &G,
-        graph_dir: impl AsRef<Path>,
-    ) -> Result<Self, RAError> {
-        let inner_graph = TemporalGraph::from_graph(graph, graph_dir.as_ref(), || {
-            make_node_properties_from_graph(graph, graph_dir.as_ref())
-        })?;
-        let mut storage = Self::new(inner_graph);
-        storage.graph_props = Arc::new(graph.graph_meta().deep_clone());
-        Ok(storage)
-    }
-
-    pub fn load_from_edge_lists(
-        edge_list: &[StructArray],
-        chunk_size: usize,
-        t_props_chunk_size: usize,
-        graph_dir: impl AsRef<Path> + Sync,
-        time_col_idx: usize,
-        src_col_idx: usize,
-        dst_col_idx: usize,
-    ) -> Result<Self, RAError> {
-        let inner = TemporalGraph::from_sorted_edge_list(
-            graph_dir,
-            src_col_idx,
-            dst_col_idx,
-            time_col_idx,
-            chunk_size,
-            t_props_chunk_size,
-            edge_list,
-        )?;
-        Ok(Self::new(inner))
-    }
-
-    pub fn load_from_dir(graph_dir: impl AsRef<Path>) -> Result<DiskGraphStorage, RAError> {
-        let inner = TemporalGraph::new(graph_dir)?;
-        Ok(Self::new(inner))
-    }
-
-    pub fn load_from_parquets<P: AsRef<Path>>(
-        graph_dir: P,
-        layer_parquet_cols: Vec<ParquetLayerCols>,
-        node_properties: Option<P>,
-        chunk_size: usize,
-        t_props_chunk_size: usize,
-        num_threads: usize,
-        node_type_col: Option<&str>,
-        node_id_col: Option<&str>,
-        num_rows: Option<usize>,
-    ) -> Result<DiskGraphStorage, RAError> {
-        let edge_lists: Vec<ExternalEdgeList<&Path>> = layer_parquet_cols
-            .into_iter()
-            .map(
-                |ParquetLayerCols {
-                     parquet_dir,
-                     layer,
-                     src_col,
-                     dst_col,
-                     time_col,
-                     exclude_edge_props,
-                 }| {
-                    ExternalEdgeList::new(
-                        layer,
-                        parquet_dir.as_ref(),
-                        src_col,
-                        dst_col,
-                        time_col,
-                        exclude_edge_props,
-                    )
-                    .expect("Failed to load events")
-                },
-            )
-            .collect::<Vec<_>>();
-
-        let t_graph = TemporalGraph::from_parquets(
-            num_threads,
-            chunk_size,
-            t_props_chunk_size,
-            graph_dir.as_ref(),
-            edge_lists,
-            &[],
-            node_properties.as_ref().map(|p| p.as_ref()),
-            node_type_col,
-            node_id_col,
-            num_rows,
-        )?;
-        Ok(Self::new(t_graph))
-    }
-
-    pub fn load_node_types_from_arrays(
-        &mut self,
-        arrays: impl IntoIterator<Item = Result<ArrayRef, RAError>>,
-        chunk_size: usize,
-    ) -> Result<(), RAError> {
-        let inner = Arc::make_mut(&mut self.inner);
-        inner.load_node_types_from_chunks(arrays, chunk_size)?;
-        Ok(())
-    }
-
-    pub fn filtered_layers_par<'a>(
-        &'a self,
-        layer_ids: LayerIds,
-    ) -> impl ParallelIterator<Item = &'a TempColGraphFragment> + 'a {
-        self.inner
-            .layers()
-            .par_iter()
-            .enumerate()
-            .filter(move |(l_id, _)| layer_ids.contains(l_id))
-            .map(|(_, layer)| layer)
-    }
-
-    pub fn filtered_layers_iter<'a>(
-        &'a self,
-        layer_ids: LayerIds,
-    ) -> impl Iterator<Item = &'a TempColGraphFragment> + 'a {
-        self.inner
-            .layers()
-            .iter()
-            .enumerate()
-            .filter(move |(l_id, _)| layer_ids.contains(l_id))
-            .map(|(_, layer)| layer)
-    }
-
-    pub fn node_meta(&self) -> &Meta {
-        self.inner.node_meta()
-    }
-
-    pub fn edge_meta(&self) -> &Meta {
-        self.inner.edge_meta()
-    }
-
-    pub fn graph_meta(&self) -> &GraphMeta {
-        &self.graph_props
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use arrow_array::{Int64Array, StructArray, UInt64Array};
-    use arrow_schema::{DataType, Field, Schema};
-    use itertools::Itertools;
-    use pometry_storage::{
-        chunked_array::array_like::{BaseArrayLike, FromVec},
-        graph::TemporalGraph,
-        RAError,
-    };
-    use proptest::{prelude::*, sample::size_range};
-    use raphtory_api::core::entities::{EID, VID};
-    use std::path::Path;
-    use tempfile::TempDir;
-
-    fn edges_sanity_node_list(edges: &[(u64, u64, i64)]) -> Vec<u64> {
-        edges
-            .iter()
-            .map(|(s, _, _)| *s)
-            .chain(edges.iter().map(|(_, d, _)| *d))
-            .sorted()
-            .dedup()
-            .collect()
-    }
-
-    pub fn edges_sanity_check_build_graph<P: AsRef<Path>>(
-        test_dir: P,
-        edges: &[(u64, u64, i64)],
-        input_chunk_size: u64,
-        chunk_size: usize,
-        t_props_chunk_size: usize,
-    ) -> Result<TemporalGraph, RAError> {
-        let chunks = edges
-            .iter()
-            .map(|(src, _, _)| *src)
-            .chunks(input_chunk_size as usize);
-        let srcs = chunks
-            .into_iter()
-            .map(|chunk| UInt64Array::from_vec(chunk.collect()));
-        let chunks = edges
-            .iter()
-            .map(|(_, dst, _)| *dst)
-            .chunks(input_chunk_size as usize);
-        let dsts = chunks
-            .into_iter()
-            .map(|chunk| UInt64Array::from_vec(chunk.collect()));
-        let chunks = edges
-            .iter()
-            .map(|(_, _, times)| *times)
-            .chunks(input_chunk_size as usize);
-        let times = chunks
-            .into_iter()
-            .map(|chunk| Int64Array::from_vec(chunk.collect()));
-
-        let schema = Schema::new(vec![
-            Field::new("srcs", DataType::UInt64, false),
-            Field::new("dsts", DataType::UInt64, false),
-            Field::new("time", DataType::Int64, false),
-        ]);
-
-        let triples = srcs
-            .zip(dsts)
-            .zip(times)
-            .map(move |((a, b), c)| {
-                StructArray::new(
-                    schema.fields.clone(),
-                    vec![a.as_array_ref(), b.as_array_ref(), c.as_array_ref()],
-                    None,
-                )
-            })
-            .collect::<Vec<_>>();
-
-        TemporalGraph::from_sorted_edge_list(
-            test_dir.as_ref(),
-            0,
-            1,
-            2,
-            chunk_size,
-            t_props_chunk_size,
-            &triples,
-        )
-    }
-
-    pub fn check_graph_sanity(edges: &[(u64, u64, i64)], nodes: &[u64], graph: &TemporalGraph) {
-        let actual_num_verts = nodes.len();
-        let g_num_verts = graph.num_nodes();
-        assert_eq!(actual_num_verts, g_num_verts);
-        assert!(graph
-            .edges_iter()
-            .map(|edge| (edge.src_id(), edge.dst_id()))
-            .all(|(VID(src), VID(dst))| src < g_num_verts && dst < g_num_verts));
-
-        for v in 0..g_num_verts {
-            let v = VID(v);
-            assert!(graph
-                .node(v, 0)
-                .out_neighbours()
-                .tuple_windows()
-                .all(|(v1, v2)| v1 <= v2));
-            assert!(graph
-                .node(v, 0)
-                .in_neighbours()
-                .tuple_windows()
-                .all(|(v1, v2)| v1 <= v2));
-        }
-
-        let exploded_edges: Vec<_> = graph
-            .exploded_edges()
-            .map(|(src, dst, time)| (nodes[src.0], nodes[dst.0], time))
-            .collect();
-        assert_eq!(exploded_edges, edges);
-
-        let mut expected_inbounds = edges
-            .iter()
-            .map(|(src, dst, _)| (*dst, *src))
-            .into_group_map();
-        for v in expected_inbounds.values_mut() {
-            v.sort();
-            v.dedup();
-        }
-
-        // check incoming edges
-        for (v_id, g_id) in nodes.iter().enumerate() {
-            let expected_inbound = match expected_inbounds.get(g_id) {
-                None => &vec![],
-                Some(res) => res,
-            };
-
-            let actual_inbound = graph
-                .node(VID(v_id), 0)
-                .in_neighbours()
-                .map(|v| nodes[v.0])
-                .collect::<Vec<_>>();
-
-            assert_eq!(&actual_inbound, expected_inbound);
-        }
-
-        let unique_edges = edges.iter().map(|(src, dst, _)| (*src, *dst)).dedup();
-
-        for (e_id, (src, dst)) in unique_edges.enumerate() {
-            let edge = graph.edge(EID(e_id));
-            let VID(src_id) = edge.src_id();
-            let VID(dst_id) = edge.dst_id();
-
-            assert_eq!(nodes[src_id], src);
-            assert_eq!(nodes[dst_id], dst);
-        }
-
-        let mut expected_node_additions = edges
-            .iter()
-            .flat_map(|(src, dst, t)| {
-                if src != dst {
-                    vec![(*src, *t), (*dst, *t)]
-                } else {
-                    vec![(*src, *t)]
-                }
-            })
-            .into_group_map();
-        for v in expected_node_additions.values_mut() {
-            v.sort();
-        }
-
-        for (v_id, node) in nodes.iter().enumerate() {
-            let expected = expected_node_additions.get(node).unwrap();
-            let node = graph.node(VID(v_id), 0);
-            let actual = node.timestamps().into_iter_t().collect::<Vec<_>>();
-            assert_eq!(&actual, expected);
-        }
-    }
-
-    fn edges_sanity_check_inner(
-        edges: Vec<(u64, u64, i64)>,
-        input_chunk_size: u64,
-        chunk_size: usize,
-        t_props_chunk_size: usize,
-    ) {
-        let test_dir = TempDir::new().unwrap();
-        let nodes = edges_sanity_node_list(&edges);
-        match edges_sanity_check_build_graph(
-            test_dir.path(),
-            &edges,
-            input_chunk_size,
-            chunk_size,
-            t_props_chunk_size,
-        ) {
-            Ok(graph) => {
-                // check graph is sane
-                check_graph_sanity(&edges, &nodes, &graph);
-
-                // check that reloading from graph dir works
-                let reloaded_graph = TemporalGraph::new(&test_dir).unwrap();
-                check_graph_sanity(&edges, &nodes, &reloaded_graph)
-            }
-            Err(RAError::NoEdgeLists | RAError::EmptyChunk) => assert!(edges.is_empty()),
-            Err(error) => panic!("{}", error.to_string()),
-        };
-    }
-
-    proptest! {
-        #[test]
-        fn edges_sanity_check(
-            edges in any_with::<Vec<(u8, u8, Vec<i64>)>>(size_range(1..=100).lift()).prop_map(|v| {
-                let mut v: Vec<(u64, u64, i64)> = v.into_iter().flat_map(|(src, dst, times)| {
-                    let src = src as u64;
-                    let dst = dst as u64;
-                    times.into_iter().map(move |t| (src, dst, t))}).collect();
-                v.sort();
-                v}),
-            input_chunk_size in 1..1024u64,
-            chunk_size in 1..1024usize,
-            t_props_chunk_size in 1..128usize
-        ) {
-            edges_sanity_check_inner(edges, input_chunk_size, chunk_size, t_props_chunk_size);
-        }
-    }
-
-    #[test]
-    fn edge_sanity_fail1() {
-        let edges = vec![(0, 17, 0), (1, 0, -1), (17, 0, 0)];
-        edges_sanity_check_inner(edges, 4, 4, 4)
-    }
-
-    #[test]
-    fn edge_sanity_bad() {
-        let edges = vec![
-            (0, 85, -8744527736816607775),
-            (0, 85, -8533859256444633783),
-            (0, 85, -7949123054744509169),
-            (0, 85, -7208573652910411733),
-            (0, 85, -7004677070223473589),
-            (0, 85, -6486844751834401685),
-            (0, 85, -6420653301843451067),
-            (0, 85, -6151481582745013767),
-            (0, 85, -5577061971106014565),
-            (0, 85, -5484794766797320810),
-        ];
-        edges_sanity_check_inner(edges, 3, 5, 12)
-    }
-
-    #[test]
-    fn edge_sanity_more_bad() {
-        let edges = vec![
-            (1, 3, -8622734205120758463),
-            (2, 0, -8064563587743129892),
-            (2, 0, 0),
-            (2, 0, 66718116),
-            (2, 0, 733950369757766878),
-            (2, 0, 2044789983495278802),
-            (2, 0, 2403967656666566197),
-            (2, 4, -9199293364914546702),
-            (2, 4, -9104424882442202562),
-            (2, 4, -8942117006530427874),
-            (2, 4, -8805351871358148900),
-            (2, 4, -8237347600058197888),
-        ];
-        edges_sanity_check_inner(edges, 3, 5, 6)
-    }
-
-    #[test]
-    fn edges_sanity_chunk_1() {
-        edges_sanity_check_inner(vec![(876787706323152993, 0, 0)], 1, 1, 1)
-    }
-
-    #[test]
-    fn edges_sanity_chunk_2() {
-        edges_sanity_check_inner(vec![(4, 3, 2), (4, 5, 0)], 2, 2, 2)
-    }
-
-    #[test]
-    fn one_edge_bounds_chunk_remainder() {
-        let edges = vec![(0u64, 1, 0)];
-        edges_sanity_check_inner(edges, 1, 3, 3);
-    }
-
-    #[test]
-    fn same_edge_twice() {
-        let edges = vec![(0, 1, 0), (0, 1, 1)];
-        edges_sanity_check_inner(edges, 2, 3, 3);
-    }
-
-    #[test]
-    fn node_additions_bounds_to_arrays() {
-        let edges = vec![(0, 0, -2), (0, 0, -1), (0, 0, 0), (0, 0, 1), (0, 0, 2)];
-        let len = edges.len();
-        edges_sanity_check_inner(edges, len as u64, 2, 2);
-    }
-
-    #[test]
-    fn large_failing_edge_sanity_repeated() {
-        let edges = vec![
-            (0, 0, 0),
-            (0, 1, 0),
-            (0, 2, 0),
-            (0, 3, 0),
-            (0, 4, 0),
-            (0, 5, 0),
-            (0, 6, -30),
-            (4, 7, -83),
-            (4, 7, -77),
-            (6, 8, -68),
-            (6, 8, -65),
-            (9, 10, 46),
-            (9, 10, 46),
-            (9, 10, 51),
-            (9, 10, 54),
-            (9, 10, 59),
-            (9, 10, 59),
-            (9, 10, 59),
-            (9, 10, 65),
-            (9, 11, -75),
-        ];
-        let input_chunk_size = 411;
-        let edge_chunk_size = 5;
-        let edge_max_list_size = 7;
-
-        edges_sanity_check_inner(edges, input_chunk_size, edge_chunk_size, edge_max_list_size);
-    }
-
-    #[test]
-    fn edge_sanity_chunk_broken_incoming() {
-        let edges = vec![
-            (0, 0, 0),
-            (0, 0, 0),
-            (0, 0, 66),
-            (0, 1, 0),
-            (2, 0, 0),
-            (3, 4, 0),
-            (4, 0, 0),
-            (4, 4, 0),
-            (4, 4, 0),
-            (4, 4, 0),
-            (4, 4, 0),
-            (5, 0, 0),
-            (6, 7, 7274856480798084567),
-            (8, 3, -7707029126214574305),
-        ];
-
-        edges_sanity_check_inner(edges, 853, 122, 98)
-    }
-
-    #[test]
-    fn edge_sanity_chunk_broken_something() {
-        let edges = vec![(0, 3, 0), (1, 2, 0), (3, 2, 0)];
-        edges_sanity_check_inner(edges, 1, 1, 1)
-    }
-}
diff --git a/raphtory-storage/src/disk/storage_interface/edge.rs b/raphtory-storage/src/disk/storage_interface/edge.rs
deleted file mode 100644
index 85fa367e52..0000000000
--- a/raphtory-storage/src/disk/storage_interface/edge.rs
+++ /dev/null
@@ -1,121 +0,0 @@
-use crate::graph::edges::edge_storage_ops::{EdgeStorageOps, TimeIndexRef};
-use pometry_storage::{edge::Edge, tprops::DiskTProp};
-use raphtory_api::core::{
-    entities::{
-        properties::{prop::Prop, tprop::TPropOps},
-        LayerIds, LayerVariants, EID, VID,
-    },
-    storage::timeindex::{EventTime, TimeIndexOps},
-};
-use raphtory_core::storage::timeindex::TimeIndex;
-use rayon::prelude::*;
-use std::{iter, ops::Range};
-
-impl<'a> EdgeStorageOps<'a> for Edge<'a> {
-    fn added(self, layer_ids: &LayerIds, w: Range<i64>) -> bool {
-        self.has_layer(layer_ids) && {
-            match layer_ids {
-                LayerIds::None => false,
-                LayerIds::All => self
-                    .additions_iter(layer_ids)
-                    .any(|(_, t_index)| t_index.active_t(w.clone())),
-                LayerIds::One(l_id) => self.get_additions::<i64>(*l_id).active_t(w),
-                LayerIds::Multiple(layers) => layers
-                    .iter()
-                    .any(|l_id| self.added(&LayerIds::One(l_id), w.clone())),
-            }
-        }
-    }
-
-    fn has_layer(self, layer_ids: &LayerIds) -> bool {
-        match layer_ids {
-            LayerIds::None => false,
-            LayerIds::All => true,
-            LayerIds::One(id) => self.has_layer_inner(*id),
-            LayerIds::Multiple(ids) => ids.iter().any(|id| self.has_layer_inner(id)),
-        }
-    }
-
-    fn src(self) -> VID {
-        self.src_id()
-    }
-
-    fn dst(self) -> VID {
-        self.dst_id()
-    }
-
-    fn eid(self) -> EID {
-        self.pid()
-    }
-
-    fn layer_ids_iter(self, layer_ids: &'a LayerIds) -> impl Iterator<Item = usize> + 'a {
-        match layer_ids {
-            LayerIds::None => LayerVariants::None(std::iter::empty()),
-            LayerIds::All => LayerVariants::All(
-                (0..self.internal_num_layers()).filter(move |&l| self.has_layer_inner(l)),
-            ),
-            LayerIds::One(id) => {
-                LayerVariants::One(self.has_layer_inner(*id).then_some(*id).into_iter())
-            }
-            LayerIds::Multiple(ids) => {
-                LayerVariants::Multiple(ids.into_iter().filter(move |&id| self.has_layer_inner(id)))
-            }
-        }
-    }
-
-    fn layer_ids_par_iter(self, layer_ids: &LayerIds) -> impl ParallelIterator<Item = usize> + 'a {
-        match layer_ids {
-            LayerIds::None => LayerVariants::None(rayon::iter::empty()),
-            LayerIds::All => LayerVariants::All(
-                (0..self.internal_num_layers())
-                    .into_par_iter()
-                    .filter(move |&l| self.has_layer_inner(l)),
-            ),
-            LayerIds::One(id) => {
-                LayerVariants::One(self.has_layer_inner(*id).then_some(*id).into_par_iter())
-            }
-            LayerIds::Multiple(ids) => {
-                LayerVariants::Multiple(ids.par_iter().filter(move |&id| self.has_layer_inner(id)))
-            }
-        }
-    }
-
-    fn deletions_iter(
-        self,
-        _layer_ids: &'a LayerIds,
-    ) -> impl Iterator<Item = (usize, TimeIndexRef<'a>)> + 'a {
-        Box::new(iter::empty())
-    }
-
-    fn deletions_par_iter(
-        self,
-        _layer_ids: &LayerIds,
-    ) -> impl ParallelIterator<Item = (usize, TimeIndexRef<'a>)> + 'a {
-        rayon::iter::empty()
-    }
-
-    fn additions(self, layer_id: usize) -> TimeIndexRef<'a> {
-        TimeIndexRef::External(self.get_additions::<EventTime>(layer_id))
-    }
-
-    fn deletions(self, _layer_id: usize) -> TimeIndexRef<'a> {
-        TimeIndexRef::Ref(&TimeIndex::Empty)
-    }
-
-    fn temporal_prop_layer(self, layer_id: usize, prop_id: usize) -> impl TPropOps<'a> + 'a {
-        self.graph()
-            .localize_edge_prop_id(layer_id, prop_id)
-            .map(|prop_id| {
-                self.graph()
-                    .layer(layer_id)
-                    .edges_storage()
-                    .prop(self.eid(), prop_id)
-            })
-            .unwrap_or(DiskTProp::empty())
-    }
-
-    fn metadata_layer(self, _layer_id: usize, _prop_id: usize) -> Option<Prop> {
-        // TODO: metadata edge properties not implemented in diskgraph yet
-        None
-    }
-}
diff --git a/raphtory-storage/src/disk/storage_interface/edges.rs b/raphtory-storage/src/disk/storage_interface/edges.rs
deleted file mode 100644
index df02191471..0000000000
--- a/raphtory-storage/src/disk/storage_interface/edges.rs
+++ /dev/null
@@ -1,88 +0,0 @@
-use crate::disk::{
-    graph_impl::DiskEdge, storage_interface::edges_ref::DiskEdgesRef, DiskGraphStorage,
-};
-use itertools::Itertools;
-use raphtory_api::{
-    core::entities::{edges::edge_ref::EdgeRef, LayerIds, LayerVariants, EID},
-    iter::IntoDynBoxed,
-};
-use raphtory_core::utils::iter::GenLockedIter;
-use rayon::iter::{IntoParallelIterator, ParallelIterator};
-use std::{iter, sync::Arc};
-
-#[derive(Clone, Debug)]
-pub struct DiskEdges {
-    graph: Arc<DiskGraphStorage>,
-}
-
-impl DiskEdges {
-    pub(crate) fn new(graph: &DiskGraphStorage) -> Self {
-        Self {
-            graph: Arc::new(graph.clone()),
-        }
-    }
-
-    pub fn as_ref(&self) -> DiskEdgesRef<'_> {
-        DiskEdgesRef {
-            graph: &self.graph.inner,
-        }
-    }
-
-    pub fn into_iter_refs(self, layer_ids: LayerIds) -> impl Iterator<Item = EdgeRef> {
-        match layer_ids {
-            LayerIds::None => LayerVariants::None(iter::empty()),
-            LayerIds::All => LayerVariants::All(GenLockedIter::from(self.graph, |graph| {
-                graph
-                    .inner
-                    .all_edge_ids()
-                    .map(|(eid, src, dst)| EdgeRef::new_outgoing(eid, src, dst))
-                    .into_dyn_boxed()
-            })),
-            LayerIds::One(layer_id) => {
-                LayerVariants::One(GenLockedIter::from(self.graph, move |graph| {
-                    graph
-                        .inner
-                        .layer_edge_ids(layer_id)
-                        .map(|(eid, src, dst)| EdgeRef::new_outgoing(eid, src, dst))
-                        .into_dyn_boxed()
-                }))
-            }
-            LayerIds::Multiple(ids) => LayerVariants::Multiple(
-                ids.into_iter()
-                    .map(move |layer_id| {
-                        GenLockedIter::from(self.graph.clone(), move |graph| {
-                            graph.inner.layer_edge_ids(layer_id).into_dyn_boxed()
-                        })
-                    })
-                    .kmerge_by(|(eid1, _, _), (eid2, _, _)| eid1 < eid2)
-                    .dedup()
-                    .map(move |(eid, src, dst)| EdgeRef::new_outgoing(eid, src, dst)),
-            ),
-        }
-    }
-
-    pub fn into_par_iter_refs(self, layer_ids: LayerIds) -> impl ParallelIterator<Item = EID> {
-        match layer_ids {
-            LayerIds::None => LayerVariants::None(rayon::iter::empty()),
-            LayerIds::One(layer_id) => {
-                LayerVariants::One(self.graph.inner.all_edge_ids_par(layer_id))
-            }
-            LayerIds::All => {
-                LayerVariants::All((0..self.graph.inner.num_edges()).into_par_iter().map(EID))
-            }
-            LayerIds::Multiple(ids) => LayerVariants::Multiple(
-                (0..self.graph.inner.num_edges())
-                    .into_par_iter()
-                    .map(EID)
-                    .filter(move |e| {
-                        ids.into_iter()
-                            .any(|layer_id| self.graph.inner.edge(*e).has_layer_inner(layer_id))
-                    }),
-            ),
-        }
-    }
-
-    pub fn get(&self, eid: EID) -> DiskEdge<'_> {
-        self.graph.inner.edge(eid)
-    }
-}
diff --git a/raphtory-storage/src/disk/storage_interface/edges_ref.rs b/raphtory-storage/src/disk/storage_interface/edges_ref.rs
deleted file mode 100644
index c638bebb6c..0000000000
--- a/raphtory-storage/src/disk/storage_interface/edges_ref.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-use crate::{disk::graph_impl::DiskEdge, graph::edges::edge_storage_ops::EdgeStorageOps};
-use pometry_storage::graph::TemporalGraph;
-use raphtory_api::core::entities::{LayerIds, LayerVariants, EID};
-use rayon::prelude::*;
-use std::iter;
-
-#[derive(Copy, Clone, Debug)]
-pub struct DiskEdgesRef<'a> {
-    pub(super) graph: &'a TemporalGraph,
-}
-
-impl<'a> DiskEdgesRef<'a> {
-    pub(crate) fn new(storage: &'a TemporalGraph) -> Self {
-        Self { graph: storage }
-    }
-
-    pub fn edge(self, eid: EID) -> DiskEdge<'a> {
-        self.graph.edge(eid)
-    }
-
-    pub fn iter(self, layers: &LayerIds) -> impl Iterator<Item = DiskEdge<'a>> + use<'a, '_> {
-        match layers {
-            LayerIds::None => LayerVariants::None(iter::empty()),
-            LayerIds::All => LayerVariants::All(self.graph.edges_iter()),
-            LayerIds::One(layer_id) => LayerVariants::One(self.graph.edges_layer_iter(*layer_id)),
-            layer_ids => LayerVariants::Multiple(
-                self.graph
-                    .edges_iter()
-                    .filter(move |e| e.has_layer(layer_ids)),
-            ),
-        }
-    }
-
-    pub fn par_iter(
-        self,
-        layers: &LayerIds,
-    ) -> impl ParallelIterator<Item = DiskEdge<'a>> + use<'a, '_> {
-        match layers {
-            LayerIds::None => LayerVariants::None(rayon::iter::empty()),
-            LayerIds::All => LayerVariants::All(self.graph.edges_par_iter()),
-            LayerIds::One(layer_id) => {
-                LayerVariants::One(self.graph.edges_layer_par_iter(*layer_id))
-            }
-            layer_ids => LayerVariants::Multiple(
-                self.graph
-                    .edges_par_iter()
-                    .filter(move |e| e.has_layer(layer_ids)),
-            ),
-        }
-    }
-
-    pub fn count(self, layers: &LayerIds) -> usize {
-        match layers {
-            LayerIds::None => 0,
-            LayerIds::All => self.graph.num_edges(),
-            LayerIds::One(id) => self.graph.layer(*id).num_edges(),
-            layer_ids => self
-                .graph
-                .edges_par_iter()
-                .filter(move |e| e.has_layer(layer_ids))
-                .count(),
-        }
-    }
-
-    pub fn len(&self) -> usize {
-        self.count(&LayerIds::All)
-    }
-}
diff --git a/raphtory-storage/src/disk/storage_interface/mod.rs b/raphtory-storage/src/disk/storage_interface/mod.rs
deleted file mode 100644
index 27f130f009..0000000000
--- a/raphtory-storage/src/disk/storage_interface/mod.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-pub mod edge;
-pub mod edges;
-pub mod edges_ref;
-pub mod node;
-pub mod nodes;
-pub mod nodes_ref;
diff --git a/raphtory-storage/src/disk/storage_interface/node.rs b/raphtory-storage/src/disk/storage_interface/node.rs
deleted file mode 100644
index 4fec7cbac5..0000000000
--- a/raphtory-storage/src/disk/storage_interface/node.rs
+++ /dev/null
@@ -1,340 +0,0 @@
-use crate::graph::nodes::{
-    node_additions::NodeAdditions,
-    node_storage_ops::NodeStorageOps,
-    row::{DiskRow, Row},
-};
-use itertools::Itertools;
-use pometry_storage::{
-    graph::TemporalGraph, timestamps::LayerAdditions, tprops::DiskTProp, GidRef,
-};
-use raphtory_api::{
-    core::{
-        entities::{
-            edges::edge_ref::EdgeRef,
-            properties::{prop::Prop, tprop::TPropOps},
-            LayerIds, LayerVariants, VID,
-        },
-        storage::timeindex::{EventTime, TimeIndexOps},
-        Direction, DirectionVariants,
-    },
-    iter::BoxedLIter,
-};
-use std::{borrow::Cow, iter, ops::Range};
-
-#[derive(Copy, Clone, Debug)]
-pub struct DiskNode<'a> {
-    graph: &'a TemporalGraph,
-    pub(super) vid: VID,
-}
-
-impl<'a> DiskNode<'a> {
-    pub fn into_rows(self) -> impl Iterator<Item = (EventTime, Row<'a>)> {
-        self.graph
-            .node_properties()
-            .temporal_props()
-            .iter()
-            .enumerate()
-            .flat_map(move |(layer, props)| {
-                let ts = props.timestamps::<EventTime>(self.vid);
-                ts.into_iter().zip(0..ts.len()).map(move |(t, row)| {
-                    let row = DiskRow::new(self.graph, ts, row, layer);
-                    (t, Row::Disk(row))
-                })
-            })
-    }
-
-    pub fn into_rows_window(
-        self,
-        window: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, Row<'a>)> {
-        self.graph
-            .node_properties()
-            .temporal_props()
-            .iter()
-            .enumerate()
-            .flat_map(move |(layer, props)| {
-                let ts = props.timestamps::<EventTime>(self.vid);
-                let ts = ts.range(window.clone());
-                ts.iter().enumerate().map(move |(row, t)| {
-                    let row = DiskRow::new(self.graph, ts, row, layer);
-                    (t, Row::Disk(row))
-                })
-            })
-    }
-
-    pub fn last_before_row(self, t: EventTime) -> Vec<(usize, Prop)> {
-        self.graph
-            .prop_mapping()
-            .nodes()
-            .iter()
-            .enumerate()
-            .filter_map(|(prop_id, &location)| {
-                let (layer, local_prop_id) = location?;
-                let layer = self.graph().node_properties().temporal_props().get(layer)?;
-                let t_prop = layer.prop::<EventTime>(self.vid, local_prop_id);
-                t_prop.last_before(t).map(|(_, p)| (prop_id, p))
-            })
-            .collect()
-    }
-
-    pub fn node_metadata_ids(self) -> BoxedLIter<'a, usize> {
-        match &self.graph.node_properties().metadata {
-            None => Box::new(std::iter::empty()),
-            Some(props) => {
-                Box::new((0..props.num_props()).filter(move |id| props.has_prop(self.vid, *id)))
-            }
-        }
-    }
-
-    pub fn temporal_node_prop_ids(self) -> impl Iterator<Item = usize> + 'a {
-        self.graph
-            .prop_mapping()
-            .nodes()
-            .iter()
-            .enumerate()
-            .filter(|(_, exists)| exists.is_some())
-            .map(|(id, _)| id)
-    }
-
-    pub(crate) fn new(graph: &'a TemporalGraph, vid: VID) -> Self {
-        Self { graph, vid }
-    }
-
-    pub fn out_edges(self, layers: &LayerIds) -> impl Iterator<Item = EdgeRef> + 'a {
-        match layers {
-            LayerIds::None => LayerVariants::None(iter::empty()),
-            LayerIds::All => LayerVariants::All(
-                self.graph
-                    .layers()
-                    .iter()
-                    .enumerate()
-                    .map(|(layer_id, layer)| {
-                        layer
-                            .nodes_storage()
-                            .out_adj_list(self.vid)
-                            .map(move |(eid, dst)| {
-                                EdgeRef::new_outgoing(eid, self.vid, dst).at_layer(layer_id)
-                            })
-                    })
-                    .kmerge_by(|e1, e2| e1.remote() <= e2.remote()),
-            ),
-            LayerIds::One(layer_id) => {
-                let layer_id = *layer_id;
-                LayerVariants::One(
-                    self.graph.layers()[layer_id]
-                        .nodes_storage()
-                        .out_adj_list(self.vid)
-                        .map(move |(eid, dst)| {
-                            EdgeRef::new_outgoing(eid, self.vid, dst).at_layer(layer_id)
-                        }),
-                )
-            }
-            LayerIds::Multiple(ids) => LayerVariants::Multiple(
-                ids.into_iter()
-                    .map(|layer_id| {
-                        self.graph.layers()[layer_id]
-                            .nodes_storage()
-                            .out_adj_list(self.vid)
-                            .map(move |(eid, dst)| {
-                                EdgeRef::new_outgoing(eid, self.vid, dst).at_layer(layer_id)
-                            })
-                    })
-                    .kmerge_by(|e1, e2| e1.remote() <= e2.remote()),
-            ),
-        }
-    }
-
-    pub fn in_edges(self, layers: &LayerIds) -> impl Iterator<Item = EdgeRef> + 'a {
-        match layers {
-            LayerIds::None => LayerVariants::None(iter::empty()),
-            LayerIds::All => LayerVariants::All(
-                self.graph
-                    .layers()
-                    .iter()
-                    .enumerate()
-                    .map(|(layer_id, layer)| {
-                        layer
-                            .nodes_storage()
-                            .in_adj_list(self.vid)
-                            .map(move |(eid, src)| {
-                                EdgeRef::new_incoming(eid, src, self.vid).at_layer(layer_id)
-                            })
-                    })
-                    .kmerge_by(|e1, e2| e1.remote() <= e2.remote()),
-            ),
-            LayerIds::One(layer_id) => {
-                let layer_id = *layer_id;
-                LayerVariants::One(
-                    self.graph.layers()[layer_id]
-                        .nodes_storage()
-                        .in_adj_list(self.vid)
-                        .map(move |(eid, src)| {
-                            EdgeRef::new_incoming(eid, src, self.vid).at_layer(layer_id)
-                        }),
-                )
-            }
-            LayerIds::Multiple(ids) => LayerVariants::Multiple(
-                ids.into_iter()
-                    .map(|layer_id| {
-                        self.graph.layers()[layer_id]
-                            .nodes_storage()
-                            .in_adj_list(self.vid)
-                            .map(move |(eid, src)| {
-                                EdgeRef::new_incoming(eid, src, self.vid).at_layer(layer_id)
-                            })
-                    })
-                    .kmerge_by(|e1, e2| e1.remote() <= e2.remote()),
-            ),
-        }
-    }
-
-    pub fn edges(self, layers: &LayerIds) -> impl Iterator<Item = EdgeRef> + 'a {
-        self.in_edges(layers)
-            .merge_by(self.out_edges(layers), |e1, e2| e1.remote() <= e2.remote())
-    }
-
-    pub fn additions_for_layers(self, layer_ids: LayerIds) -> NodeAdditions<'a> {
-        NodeAdditions::Col(LayerAdditions::new(self.graph, self.vid, layer_ids, None))
-    }
-
-    pub fn graph(&self) -> &TemporalGraph {
-        self.graph
-    }
-}
-
-impl<'a> NodeStorageOps<'a> for DiskNode<'a> {
-    fn degree(self, layers: &LayerIds, dir: Direction) -> usize {
-        let single_layer = match &layers {
-            LayerIds::None => return 0,
-            LayerIds::All => match self.graph.layers().len() {
-                0 => return 0,
-                1 => Some(&self.graph.layers()[0]),
-                _ => None,
-            },
-            LayerIds::One(id) => Some(&self.graph.layers()[*id]),
-            LayerIds::Multiple(ids) => match ids.len() {
-                0 => return 0,
-                1 => Some(&self.graph.layers()[ids.get_id_by_index(0).unwrap()]),
-                _ => None,
-            },
-        };
-        match dir {
-            Direction::OUT => match single_layer {
-                None => self
-                    .out_edges(layers)
-                    .dedup_by(|e1, e2| e1.remote() == e2.remote())
-                    .count(),
-                Some(layer) => layer.nodes_storage().out_degree(self.vid),
-            },
-            Direction::IN => match single_layer {
-                None => self
-                    .in_edges(layers)
-                    .dedup_by(|e1, e2| e1.remote() == e2.remote())
-                    .count(),
-                Some(layer) => layer.nodes_storage().in_degree(self.vid),
-            },
-            Direction::BOTH => match single_layer {
-                None => self
-                    .edges(layers)
-                    .dedup_by(|e1, e2| e1.remote() == e2.remote())
-                    .count(),
-                Some(layer) => layer
-                    .nodes_storage()
-                    .in_neighbours_iter(self.vid)
-                    .merge(layer.nodes_storage().out_neighbours_iter(self.vid))
-                    .dedup()
-                    .count(),
-            },
-        }
-    }
-
-    fn additions(self) -> NodeAdditions<'a> {
-        self.additions_for_layers(LayerIds::All)
-    }
-
-    fn tprop(self, prop_id: usize) -> impl TPropOps<'a> {
-        self.graph
-            .prop_mapping()
-            .localise_node_prop_id(prop_id)
-            .and_then(|(layer, local_prop_id)| {
-                self.graph
-                    .node_properties()
-                    .temporal_props()
-                    .get(layer)
-                    .map(|t_props| t_props.prop(self.vid, local_prop_id))
-            })
-            .unwrap_or(DiskTProp::empty())
-    }
-
-    fn tprops(self) -> impl Iterator<Item = (usize, impl TPropOps<'a>)> {
-        self.graph
-            .node_properties()
-            .temporal_props()
-            .iter()
-            .flat_map(move |t_props| t_props.props(self.vid))
-            .enumerate()
-    }
-
-    fn prop(self, prop_id: usize) -> Option<Prop> {
-        let cprops = self.graph.node_properties().metadata.as_ref()?;
-        cprops.prop_value(self.vid, prop_id)
-    }
-
-    fn edges_iter(
-        self,
-        layers: &LayerIds,
-        dir: Direction,
-    ) -> impl Iterator<Item = EdgeRef> + Send + 'a {
-        match dir {
-            Direction::OUT => DirectionVariants::Out(self.out_edges(layers)),
-            Direction::IN => DirectionVariants::In(self.in_edges(layers)),
-            Direction::BOTH => DirectionVariants::Both(self.edges(layers)),
-        }
-        .map(|e| e.unexplode())
-        .dedup_by(|l, r| l.pid() == r.pid())
-    }
-
-    fn node_type_id(self) -> usize {
-        self.graph.node_type_id(self.vid)
-    }
-
-    fn vid(self) -> VID {
-        self.vid
-    }
-
-    fn id(self) -> GidRef<'a> {
-        self.graph.node_gid(self.vid).unwrap()
-    }
-
-    fn name(self) -> Option<Cow<'a, str>> {
-        match self.graph.node_gid(self.vid).unwrap() {
-            GidRef::U64(_) => None,
-            GidRef::Str(v) => Some(Cow::from(v)),
-        }
-    }
-
-    fn find_edge(self, dst: VID, layer_ids: &LayerIds) -> Option<EdgeRef> {
-        match layer_ids {
-            LayerIds::None => None,
-            LayerIds::All => self
-                .graph
-                .find_edge(self.vid, dst)
-                .map(|e| EdgeRef::new_outgoing(e.pid(), self.vid, dst)),
-            LayerIds::One(id) => {
-                let eid = self.graph.layers()[*id]
-                    .nodes_storage()
-                    .find_edge(self.vid, dst)?;
-                Some(EdgeRef::new_outgoing(eid, self.vid, dst))
-            }
-            LayerIds::Multiple(ids) => ids
-                .iter()
-                .filter_map(|layer_id| {
-                    self.graph.layers()[layer_id]
-                        .nodes_storage()
-                        .find_edge(self.vid, dst)
-                        .map(|eid| EdgeRef::new_outgoing(eid, self.vid, dst))
-                })
-                .next(),
-        }
-    }
-}
diff --git a/raphtory-storage/src/disk/storage_interface/nodes.rs b/raphtory-storage/src/disk/storage_interface/nodes.rs
deleted file mode 100644
index 15ec8b731d..0000000000
--- a/raphtory-storage/src/disk/storage_interface/nodes.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-use crate::disk::storage_interface::{node::DiskNode, nodes_ref::DiskNodesRef};
-use pometry_storage::graph::TemporalGraph;
-use raphtory_api::core::entities::VID;
-use std::sync::Arc;
-
-#[derive(Clone, Debug)]
-pub struct DiskNodesOwned {
-    graph: Arc<TemporalGraph>,
-}
-
-impl DiskNodesOwned {
-    pub(crate) fn new(graph: Arc<TemporalGraph>) -> Self {
-        Self { graph }
-    }
-
-    pub fn node(&self, vid: VID) -> DiskNode<'_> {
-        DiskNode::new(&self.graph, vid)
-    }
-
-    pub fn as_ref(&self) -> DiskNodesRef<'_> {
-        DiskNodesRef::new(&self.graph)
-    }
-}
diff --git a/raphtory-storage/src/disk/storage_interface/nodes_ref.rs b/raphtory-storage/src/disk/storage_interface/nodes_ref.rs
deleted file mode 100644
index bd5ba75b7c..0000000000
--- a/raphtory-storage/src/disk/storage_interface/nodes_ref.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-use crate::disk::storage_interface::node::DiskNode;
-use pometry_storage::graph::TemporalGraph;
-use raphtory_api::core::entities::VID;
-use rayon::iter::{IndexedParallelIterator, IntoParallelIterator, ParallelIterator};
-
-#[derive(Copy, Clone, Debug)]
-pub struct DiskNodesRef<'a> {
-    graph: &'a TemporalGraph,
-}
-
-impl<'a> DiskNodesRef<'a> {
-    pub(crate) fn new(graph: &'a TemporalGraph) -> Self {
-        Self { graph }
-    }
-
-    pub fn len(&self) -> usize {
-        self.graph.num_nodes()
-    }
-
-    pub fn node(self, vid: VID) -> DiskNode<'a> {
-        DiskNode::new(self.graph, vid)
-    }
-
-    pub fn par_iter(self) -> impl IndexedParallelIterator<Item = DiskNode<'a>> {
-        (0..self.graph.num_nodes())
-            .into_par_iter()
-            .map(move |vid| self.node(VID(vid)))
-    }
-
-    pub fn iter(self) -> impl Iterator<Item = DiskNode<'a>> {
-        (0..self.graph.num_nodes()).map(move |vid| self.node(VID(vid)))
-    }
-}
diff --git a/raphtory-storage/src/durability_ops.rs b/raphtory-storage/src/durability_ops.rs
new file mode 100644
index 0000000000..663aa63164
--- /dev/null
+++ b/raphtory-storage/src/durability_ops.rs
@@ -0,0 +1,25 @@
+use crate::{graph::graph::GraphStorage, mutation::MutationError};
+use storage::{transaction::TransactionManager, ControlFile, Wal};
+
+/// Accessor methods for supporting durability.
+pub trait DurabilityOps {
+    fn transaction_manager(&self) -> Result<&TransactionManager, MutationError>;
+
+    fn wal(&self) -> Result<&Wal, MutationError>;
+
+    fn control_file(&self) -> Result<&ControlFile, MutationError>;
+}
+
+impl DurabilityOps for GraphStorage {
+    fn transaction_manager(&self) -> Result<&TransactionManager, MutationError> {
+        self.mutable()?.transaction_manager()
+    }
+
+    fn wal(&self) -> Result<&Wal, MutationError> {
+        self.mutable()?.wal()
+    }
+
+    fn control_file(&self) -> Result<&ControlFile, MutationError> {
+        self.mutable()?.control_file()
+    }
+}
diff --git a/raphtory-storage/src/graph/edges/edge_entry.rs b/raphtory-storage/src/graph/edges/edge_entry.rs
index 4fdd421451..83409ec812 100644
--- a/raphtory-storage/src/graph/edges/edge_entry.rs
+++ b/raphtory-storage/src/graph/edges/edge_entry.rs
@@ -1,34 +1,24 @@
-use crate::graph::edges::{
-    edge_ref::EdgeStorageRef,
-    edge_storage_ops::{EdgeStorageOps, TimeIndexRef},
-};
+use crate::graph::edges::edge_storage_ops::EdgeStorageOps;
 use raphtory_api::core::entities::{
     properties::{prop::Prop, tprop::TPropOps},
-    LayerIds, EID, VID,
+    LayerId,
 };
-use raphtory_core::{entities::edges::edge_store::MemEdge, storage::raw_edges::EdgeRGuard};
-use rayon::prelude::*;
+use raphtory_core::entities::{LayerIds, EID, VID};
 use std::ops::Range;
-
-#[cfg(feature = "storage")]
-use crate::disk::graph_impl::DiskEdge;
+use storage::{api::edges::EdgeEntryOps, EdgeEntry, EdgeEntryRef};
 
 #[derive(Debug)]
 pub enum EdgeStorageEntry<'a> {
-    Mem(MemEdge<'a>),
-    Unlocked(EdgeRGuard<'a>),
-    #[cfg(feature = "storage")]
-    Disk(DiskEdge<'a>),
+    Mem(EdgeEntryRef<'a>),
+    Unlocked(EdgeEntry<'a>),
 }
 
 impl<'a> EdgeStorageEntry<'a> {
     #[inline]
-    pub fn as_ref(&self) -> EdgeStorageRef<'_> {
+    pub fn as_ref(&self) -> EdgeEntryRef<'_> {
         match self {
-            EdgeStorageEntry::Mem(edge) => EdgeStorageRef::Mem(*edge),
-            EdgeStorageEntry::Unlocked(edge) => EdgeStorageRef::Mem(edge.as_mem_edge()),
-            #[cfg(feature = "storage")]
-            EdgeStorageEntry::Disk(edge) => EdgeStorageRef::Disk(*edge),
+            EdgeStorageEntry::Mem(edge) => *edge,
+            EdgeStorageEntry::Unlocked(edge) => edge.as_ref(),
         }
     }
 }
@@ -54,65 +44,46 @@ impl<'a, 'b: 'a> EdgeStorageOps<'a> for &'a EdgeStorageEntry<'b> {
         self.as_ref().eid()
     }
 
-    fn layer_ids_iter(self, layer_ids: &'a LayerIds) -> impl Iterator<Item = usize> + 'a {
+    fn layer_ids_iter(self, layer_ids: &'a LayerIds) -> impl Iterator<Item = LayerId> + 'a {
         self.as_ref().layer_ids_iter(layer_ids)
     }
 
-    fn layer_ids_par_iter(self, layer_ids: &LayerIds) -> impl ParallelIterator<Item = usize> + 'a {
-        self.as_ref().layer_ids_par_iter(layer_ids)
-    }
-
     fn additions_iter(
         self,
         layer_ids: &'a LayerIds,
-    ) -> impl Iterator<Item = (usize, TimeIndexRef<'a>)> + 'a {
+    ) -> impl Iterator<Item = (LayerId, storage::EdgeAdditions<'a>)> + 'a {
         self.as_ref().additions_iter(layer_ids)
     }
 
-    fn additions_par_iter(
-        self,
-        layer_ids: &LayerIds,
-    ) -> impl ParallelIterator<Item = (usize, TimeIndexRef<'a>)> + 'a {
-        self.as_ref().additions_par_iter(layer_ids)
-    }
-
     fn deletions_iter(
         self,
         layer_ids: &'a LayerIds,
-    ) -> impl Iterator<Item = (usize, TimeIndexRef<'a>)> + 'a {
+    ) -> impl Iterator<Item = (LayerId, storage::EdgeDeletions<'a>)> + 'a {
         self.as_ref().deletions_iter(layer_ids)
     }
 
-    fn deletions_par_iter(
-        self,
-        layer_ids: &LayerIds,
-    ) -> impl ParallelIterator<Item = (usize, TimeIndexRef<'a>)> + 'a {
-        self.as_ref().deletions_par_iter(layer_ids)
-    }
-
     fn updates_iter(
         self,
         layer_ids: &'a LayerIds,
-    ) -> impl Iterator<Item = (usize, TimeIndexRef<'a>, TimeIndexRef<'a>)> + 'a {
+    ) -> impl Iterator<
+        Item = (
+            LayerId,
+            storage::EdgeAdditions<'a>,
+            storage::EdgeDeletions<'a>,
+        ),
+    > + 'a {
         self.as_ref().updates_iter(layer_ids)
     }
 
-    fn updates_par_iter(
-        self,
-        layer_ids: &LayerIds,
-    ) -> impl ParallelIterator<Item = (usize, TimeIndexRef<'a>, TimeIndexRef<'a>)> + 'a {
-        self.as_ref().updates_par_iter(layer_ids)
-    }
-
-    fn additions(self, layer_id: usize) -> TimeIndexRef<'a> {
+    fn additions(self, layer_id: LayerId) -> storage::EdgeAdditions<'a> {
         self.as_ref().additions(layer_id)
     }
 
-    fn deletions(self, layer_id: usize) -> TimeIndexRef<'a> {
+    fn deletions(self, layer_id: LayerId) -> storage::EdgeDeletions<'a> {
         self.as_ref().deletions(layer_id)
     }
 
-    fn temporal_prop_layer(self, layer_id: usize, prop_id: usize) -> impl TPropOps<'a> + 'a {
+    fn temporal_prop_layer(self, layer_id: LayerId, prop_id: usize) -> impl TPropOps<'a> + 'a {
         self.as_ref().temporal_prop_layer(layer_id, prop_id)
     }
 
@@ -120,19 +91,11 @@ impl<'a, 'b: 'a> EdgeStorageOps<'a> for &'a EdgeStorageEntry<'b> {
         self,
         layer_ids: &'a LayerIds,
         prop_id: usize,
-    ) -> impl Iterator<Item = (usize, impl TPropOps<'a>)> + 'a {
+    ) -> impl Iterator<Item = (LayerId, impl TPropOps<'a>)> + 'a {
         self.as_ref().temporal_prop_iter(layer_ids, prop_id)
     }
 
-    fn temporal_prop_par_iter(
-        self,
-        layer_ids: &LayerIds,
-        prop_id: usize,
-    ) -> impl ParallelIterator<Item = (usize, impl TPropOps<'a>)> + 'a {
-        self.as_ref().temporal_prop_par_iter(layer_ids, prop_id)
-    }
-
-    fn metadata_layer(self, layer_id: usize, prop_id: usize) -> Option<Prop> {
+    fn metadata_layer(self, layer_id: LayerId, prop_id: usize) -> Option<Prop> {
         self.as_ref().metadata_layer(layer_id, prop_id)
     }
 }
diff --git a/raphtory-storage/src/graph/edges/edge_ref.rs b/raphtory-storage/src/graph/edges/edge_ref.rs
index 381f339dd1..05f844d60f 100644
--- a/raphtory-storage/src/graph/edges/edge_ref.rs
+++ b/raphtory-storage/src/graph/edges/edge_ref.rs
@@ -1,135 +1 @@
-use crate::graph::edges::edge_storage_ops::{EdgeStorageOps, TimeIndexRef};
-use raphtory_api::core::entities::{
-    properties::{prop::Prop, tprop::TPropOps},
-    LayerIds, EID, VID,
-};
-use raphtory_core::entities::edges::edge_store::MemEdge;
-use rayon::prelude::*;
-use std::ops::Range;
-
-#[cfg(feature = "storage")]
-use crate::{disk::graph_impl::DiskEdge, graph::variants::storage_variants2::StorageVariants2};
-
-macro_rules! for_all {
-    ($value:expr, $pattern:pat => $result:expr) => {
-        match $value {
-            EdgeStorageRef::Mem($pattern) => $result,
-            #[cfg(feature = "storage")]
-            EdgeStorageRef::Disk($pattern) => $result,
-        }
-    };
-}
-
-#[cfg(feature = "storage")]
-macro_rules! for_all_iter {
-    ($value:expr, $pattern:pat => $result:expr) => {
-        match $value {
-            EdgeStorageRef::Mem($pattern) => StorageVariants2::Mem($result),
-            EdgeStorageRef::Disk($pattern) => StorageVariants2::Disk($result),
-        }
-    };
-}
-
-#[cfg(not(feature = "storage"))]
-macro_rules! for_all_iter {
-    ($value:expr, $pattern:pat => $result:expr) => {
-        match $value {
-            EdgeStorageRef::Mem($pattern) => $result,
-        }
-    };
-}
-
-#[derive(Copy, Clone, Debug)]
-pub enum EdgeStorageRef<'a> {
-    Mem(MemEdge<'a>),
-    #[cfg(feature = "storage")]
-    Disk(DiskEdge<'a>),
-}
-
-impl<'a> EdgeStorageOps<'a> for EdgeStorageRef<'a> {
-    fn added(self, layer_ids: &LayerIds, w: Range<i64>) -> bool {
-        for_all!(self, edge => EdgeStorageOps::added(edge, layer_ids, w))
-    }
-
-    fn has_layer(self, layer_ids: &LayerIds) -> bool {
-        for_all!(self, edge => EdgeStorageOps::has_layer(edge, layer_ids))
-    }
-
-    fn src(self) -> VID {
-        for_all!(self, edge => edge.src())
-    }
-
-    fn dst(self) -> VID {
-        for_all!(self, edge => edge.dst())
-    }
-
-    fn eid(self) -> EID {
-        for_all!(self, edge => edge.eid())
-    }
-
-    fn layer_ids_iter(self, layer_ids: &'a LayerIds) -> impl Iterator<Item = usize> + 'a {
-        for_all_iter!(self, edge => EdgeStorageOps::layer_ids_iter(edge, layer_ids))
-    }
-
-    fn layer_ids_par_iter(self, layer_ids: &LayerIds) -> impl ParallelIterator<Item = usize> + 'a {
-        for_all_iter!(self, edge => EdgeStorageOps::layer_ids_par_iter(edge, layer_ids))
-    }
-
-    fn additions_iter(
-        self,
-        layer_ids: &'a LayerIds,
-    ) -> impl Iterator<Item = (usize, TimeIndexRef<'a>)> + 'a {
-        for_all_iter!(self, edge => EdgeStorageOps::additions_iter(edge, layer_ids))
-    }
-
-    fn additions_par_iter(
-        self,
-        layer_ids: &LayerIds,
-    ) -> impl ParallelIterator<Item = (usize, TimeIndexRef<'a>)> + 'a {
-        for_all_iter!(self, edge => EdgeStorageOps::additions_par_iter(edge, layer_ids))
-    }
-
-    fn deletions_iter(
-        self,
-        layer_ids: &'a LayerIds,
-    ) -> impl Iterator<Item = (usize, TimeIndexRef<'a>)> + 'a {
-        for_all_iter!(self, edge => EdgeStorageOps::deletions_iter(edge, layer_ids))
-    }
-
-    fn deletions_par_iter(
-        self,
-        layer_ids: &LayerIds,
-    ) -> impl ParallelIterator<Item = (usize, TimeIndexRef<'a>)> + 'a {
-        for_all_iter!(self, edge => EdgeStorageOps::deletions_par_iter(edge, layer_ids))
-    }
-
-    fn updates_iter(
-        self,
-        layer_ids: &'a LayerIds,
-    ) -> impl Iterator<Item = (usize, TimeIndexRef<'a>, TimeIndexRef<'a>)> + 'a {
-        for_all_iter!(self, edge => EdgeStorageOps::updates_iter(edge, layer_ids))
-    }
-
-    fn updates_par_iter(
-        self,
-        layer_ids: &LayerIds,
-    ) -> impl ParallelIterator<Item = (usize, TimeIndexRef<'a>, TimeIndexRef<'a>)> + 'a {
-        for_all_iter!(self, edge => EdgeStorageOps::updates_par_iter(edge, layer_ids))
-    }
-
-    fn additions(self, layer_id: usize) -> TimeIndexRef<'a> {
-        for_all!(self, edge => EdgeStorageOps::additions(edge, layer_id))
-    }
-
-    fn deletions(self, layer_id: usize) -> TimeIndexRef<'a> {
-        for_all!(self, edge => EdgeStorageOps::deletions(edge, layer_id))
-    }
-
-    fn temporal_prop_layer(self, layer_id: usize, prop_id: usize) -> impl TPropOps<'a> + 'a {
-        for_all_iter!(self, edge => edge.temporal_prop_layer(layer_id, prop_id))
-    }
-
-    fn metadata_layer(self, layer_id: usize, prop_id: usize) -> Option<Prop> {
-        for_all!(self, edge => edge.metadata_layer(layer_id, prop_id))
-    }
-}
+pub use storage::EdgeEntryRef;
diff --git a/raphtory-storage/src/graph/edges/edge_storage_ops.rs b/raphtory-storage/src/graph/edges/edge_storage_ops.rs
index cba50dadba..83ffd69065 100644
--- a/raphtory-storage/src/graph/edges/edge_storage_ops.rs
+++ b/raphtory-storage/src/graph/edges/edge_storage_ops.rs
@@ -1,35 +1,26 @@
 use iter_enum::{DoubleEndedIterator, ExactSizeIterator, FusedIterator, Iterator};
-#[cfg(feature = "storage")]
-use pometry_storage::timestamps::TimeStamps;
 use raphtory_api::core::{
     entities::{
         edges::edge_ref::{Dir, EdgeRef},
         properties::{prop::Prop, tprop::TPropOps},
-        LayerIds, LayerVariants, EID, VID,
+        LayerId, LayerIds, LayerVariants, EID, VID,
     },
     storage::timeindex::{EventTime, TimeIndexOps},
 };
-use raphtory_core::{
-    entities::{edges::edge_store::MemEdge, properties::tprop::TProp},
-    storage::timeindex::{TimeIndex, TimeIndexWindow},
-};
-use rayon::prelude::*;
+use raphtory_core::storage::timeindex::{TimeIndex, TimeIndexWindow};
 use std::ops::Range;
+use storage::api::edges::EdgeRefOps;
 
 #[derive(Clone)]
 pub enum TimeIndexRef<'a> {
     Ref(&'a TimeIndex<EventTime>),
     Range(TimeIndexWindow<'a, EventTime, TimeIndex<EventTime>>),
-    #[cfg(feature = "storage")]
-    External(TimeStamps<'a, EventTime>),
 }
 
 #[derive(Iterator, DoubleEndedIterator, ExactSizeIterator, FusedIterator, Debug, Clone)]
-pub enum TimeIndexRefVariants<Ref, Range, #[cfg(feature = "storage")] External> {
+pub enum TimeIndexRefVariants<Ref, Range> {
     Ref(Ref),
     Range(Range),
-    #[cfg(feature = "storage")]
-    External(External),
 }
 
 impl<'a> TimeIndexOps<'a> for TimeIndexRef<'a> {
@@ -40,36 +31,28 @@ impl<'a> TimeIndexOps<'a> for TimeIndexRef<'a> {
     fn active(&self, w: Range<EventTime>) -> bool {
         match self {
             TimeIndexRef::Ref(t) => t.active(w),
-            TimeIndexRef::Range(ref t) => t.active(w),
-            #[cfg(feature = "storage")]
-            TimeIndexRef::External(ref t) => t.active(w),
+            TimeIndexRef::Range(t) => t.active(w),
         }
     }
 
     fn range(&self, w: Range<EventTime>) -> Self {
         match self {
             TimeIndexRef::Ref(t) => TimeIndexRef::Range(t.range(w)),
-            TimeIndexRef::Range(ref t) => TimeIndexRef::Range(t.range(w)),
-            #[cfg(feature = "storage")]
-            TimeIndexRef::External(ref t) => TimeIndexRef::External(t.range(w)),
+            TimeIndexRef::Range(t) => TimeIndexRef::Range(t.range(w)),
         }
     }
 
     fn first(&self) -> Option<Self::IndexType> {
         match self {
             TimeIndexRef::Ref(t) => t.first(),
-            TimeIndexRef::Range(ref t) => t.first(),
-            #[cfg(feature = "storage")]
-            TimeIndexRef::External(ref t) => t.first(),
+            TimeIndexRef::Range(t) => t.first(),
         }
     }
 
     fn last(&self) -> Option<Self::IndexType> {
         match self {
             TimeIndexRef::Ref(t) => t.last(),
-            TimeIndexRef::Range(ref t) => t.last(),
-            #[cfg(feature = "storage")]
-            TimeIndexRef::External(ref t) => t.last(),
+            TimeIndexRef::Range(t) => t.last(),
         }
     }
 
@@ -77,8 +60,6 @@ impl<'a> TimeIndexOps<'a> for TimeIndexRef<'a> {
         match self {
             TimeIndexRef::Ref(t) => TimeIndexRefVariants::Ref(t.iter()),
             TimeIndexRef::Range(t) => TimeIndexRefVariants::Range(t.iter()),
-            #[cfg(feature = "storage")]
-            TimeIndexRef::External(t) => TimeIndexRefVariants::External(t.iter()),
         }
     }
 
@@ -86,8 +67,6 @@ impl<'a> TimeIndexOps<'a> for TimeIndexRef<'a> {
         match self {
             TimeIndexRef::Ref(t) => TimeIndexRefVariants::Ref(t.iter_rev()),
             TimeIndexRef::Range(t) => TimeIndexRefVariants::Range(t.iter_rev()),
-            #[cfg(feature = "storage")]
-            TimeIndexRef::External(t) => TimeIndexRefVariants::External(t.iter_rev()),
         }
     }
 
@@ -95,8 +74,6 @@ impl<'a> TimeIndexOps<'a> for TimeIndexRef<'a> {
         match self {
             TimeIndexRef::Ref(ts) => ts.len(),
             TimeIndexRef::Range(ts) => ts.len(),
-            #[cfg(feature = "storage")]
-            TimeIndexRef::External(ref t) => t.len(),
         }
     }
 }
@@ -105,6 +82,7 @@ pub trait EdgeStorageOps<'a>: Copy + Sized + Send + Sync + 'a {
     fn edge_ref(self, dir: Dir) -> EdgeRef {
         EdgeRef::new(self.eid(), self.src(), self.dst(), dir)
     }
+
     fn out_ref(self) -> EdgeRef {
         self.edge_ref(Dir::Out)
     }
@@ -119,143 +97,127 @@ pub trait EdgeStorageOps<'a>: Copy + Sized + Send + Sync + 'a {
     }
 
     fn has_layer(self, layer_ids: &LayerIds) -> bool;
+
     fn src(self) -> VID;
+
     fn dst(self) -> VID;
+
     fn eid(self) -> EID;
 
     fn layer_ids_iter(
         self,
         layer_ids: &'a LayerIds,
-    ) -> impl Iterator<Item = usize> + Send + Sync + 'a;
-
-    fn layer_ids_par_iter(self, layer_ids: &LayerIds) -> impl ParallelIterator<Item = usize> + 'a;
+    ) -> impl Iterator<Item = LayerId> + Send + Sync + 'a;
 
     fn additions_iter(
         self,
         layer_ids: &'a LayerIds,
-    ) -> impl Iterator<Item = (usize, TimeIndexRef<'a>)> + Send + Sync + 'a {
+    ) -> impl Iterator<Item = (LayerId, storage::EdgeAdditions<'a>)> + Send + Sync + 'a {
         self.layer_ids_iter(layer_ids)
             .map(move |id| (id, self.additions(id)))
     }
 
-    fn additions_par_iter(
-        self,
-        layer_ids: &LayerIds,
-    ) -> impl ParallelIterator<Item = (usize, TimeIndexRef<'a>)> + 'a {
-        self.layer_ids_par_iter(layer_ids)
-            .map(move |id| (id, self.additions(id)))
-    }
     fn deletions_iter(
         self,
         layer_ids: &'a LayerIds,
-    ) -> impl Iterator<Item = (usize, TimeIndexRef<'a>)> + 'a {
+    ) -> impl Iterator<Item = (LayerId, storage::EdgeDeletions<'a>)> + 'a {
         self.layer_ids_iter(layer_ids)
             .map(move |id| (id, self.deletions(id)))
     }
 
-    fn deletions_par_iter(
-        self,
-        layer_ids: &LayerIds,
-    ) -> impl ParallelIterator<Item = (usize, TimeIndexRef<'a>)> + 'a {
-        self.layer_ids_par_iter(layer_ids)
-            .map(move |id| (id, self.deletions(id)))
-    }
-
     fn updates_iter(
         self,
         layer_ids: &'a LayerIds,
-    ) -> impl Iterator<Item = (usize, TimeIndexRef<'a>, TimeIndexRef<'a>)> + 'a {
+    ) -> impl Iterator<
+        Item = (
+            LayerId,
+            storage::EdgeAdditions<'a>,
+            storage::EdgeDeletions<'a>,
+        ),
+    > + 'a {
         self.layer_ids_iter(layer_ids)
             .map(move |id| (id, self.additions(id), self.deletions(id)))
     }
 
-    fn updates_par_iter(
-        self,
-        layer_ids: &LayerIds,
-    ) -> impl ParallelIterator<Item = (usize, TimeIndexRef<'a>, TimeIndexRef<'a>)> + 'a {
-        self.layer_ids_par_iter(layer_ids)
-            .map(move |id| (id, self.additions(id), self.deletions(id)))
-    }
-
-    fn additions(self, layer_id: usize) -> TimeIndexRef<'a>;
+    fn additions(self, layer_id: LayerId) -> storage::EdgeAdditions<'a>;
 
-    fn deletions(self, layer_id: usize) -> TimeIndexRef<'a>;
+    fn deletions(self, layer_id: LayerId) -> storage::EdgeDeletions<'a>;
 
-    fn temporal_prop_layer(self, layer_id: usize, prop_id: usize) -> impl TPropOps<'a> + 'a;
+    fn temporal_prop_layer(self, layer_id: LayerId, prop_id: usize) -> impl TPropOps<'a> + 'a;
 
     fn temporal_prop_iter(
         self,
         layer_ids: &'a LayerIds,
         prop_id: usize,
-    ) -> impl Iterator<Item = (usize, impl TPropOps<'a>)> + 'a {
+    ) -> impl Iterator<Item = (LayerId, impl TPropOps<'a>)> + 'a {
         self.layer_ids_iter(layer_ids)
             .map(move |id| (id, self.temporal_prop_layer(id, prop_id)))
     }
 
-    fn temporal_prop_par_iter(
-        self,
-        layer_ids: &LayerIds,
-        prop_id: usize,
-    ) -> impl ParallelIterator<Item = (usize, impl TPropOps<'a>)> + 'a {
-        self.layer_ids_par_iter(layer_ids)
-            .map(move |id| (id, self.temporal_prop_layer(id, prop_id)))
-    }
-
-    fn metadata_layer(self, layer_id: usize, prop_id: usize) -> Option<Prop>;
+    fn metadata_layer(self, layer_id: LayerId, prop_id: usize) -> Option<Prop>;
 
     fn metadata_iter(
         self,
         layer_ids: &'a LayerIds,
         prop_id: usize,
-    ) -> impl Iterator<Item = (usize, Prop)> + 'a {
+    ) -> impl Iterator<Item = (LayerId, Prop)> + 'a {
         self.layer_ids_iter(layer_ids)
             .filter_map(move |id| Some((id, self.metadata_layer(id, prop_id)?)))
     }
 }
 
-impl<'a> EdgeStorageOps<'a> for MemEdge<'a> {
+impl<'a> EdgeStorageOps<'a> for storage::EdgeEntryRef<'a> {
     fn added(self, layer_ids: &LayerIds, w: Range<i64>) -> bool {
         match layer_ids {
             LayerIds::None => false,
             LayerIds::All => self
                 .additions_iter(&LayerIds::All)
                 .any(|(_, t_index)| t_index.active_t(w.clone())),
-            LayerIds::One(l_id) => self
-                .get_additions(*l_id)
-                .filter(|a| a.active_t(w))
-                .is_some(),
+            LayerIds::One(l_id) => self.layer_additions(*l_id).active_t(w),
             LayerIds::Multiple(layers) => layers
                 .iter()
-                .any(|l_id| self.added(&LayerIds::One(l_id), w.clone())),
+                .any(|l_id| self.layer_additions(l_id).active_t(w.clone())),
         }
     }
 
     fn has_layer(self, layer_ids: &LayerIds) -> bool {
         match layer_ids {
             LayerIds::None => false,
-            LayerIds::All => true,
-            LayerIds::One(id) => self.has_layer_inner(*id),
-            LayerIds::Multiple(ids) => ids.iter().any(|id| self.has_layer_inner(id)),
+            LayerIds::All => self.edge(LayerId(0)).is_some(),
+            LayerIds::One(id) => self.edge(*id).is_some(),
+            LayerIds::Multiple(ids) => self.has_layers(ids),
         }
     }
 
     fn src(self) -> VID {
-        self.edge_store().src
+        EdgeRefOps::src(&self).unwrap_or_else(|| {
+            panic!(
+                "EdgeRefOps::src should not return None for eid {:?}",
+                self.eid(),
+            )
+        })
     }
 
     fn dst(self) -> VID {
-        self.edge_store().dst
+        EdgeRefOps::dst(&self).unwrap_or_else(|| {
+            panic!(
+                "EdgeRefOps::dst should not return None for eid {:?}",
+                self.eid(),
+            )
+        })
     }
 
     fn eid(self) -> EID {
-        self.eid()
+        EdgeRefOps::edge_id(&self)
     }
 
-    fn layer_ids_iter(self, layer_ids: &'a LayerIds) -> impl Iterator<Item = usize> + 'a {
+    fn layer_ids_iter(self, layer_ids: &'a LayerIds) -> impl Iterator<Item = LayerId> + 'a {
         match layer_ids {
             LayerIds::None => LayerVariants::None(std::iter::empty()),
             LayerIds::All => LayerVariants::All(
-                (0..self.internal_num_layers()).filter(move |&l| self.has_layer_inner(l)),
+                (1..self.internal_num_layers())
+                    .map(LayerId)
+                    .filter(move |&l| self.has_layer_inner(l)),
             ),
             LayerIds::One(id) => {
                 LayerVariants::One(self.has_layer_inner(*id).then_some(*id).into_iter())
@@ -266,40 +228,20 @@ impl<'a> EdgeStorageOps<'a> for MemEdge<'a> {
         }
     }
 
-    fn layer_ids_par_iter(self, layer_ids: &LayerIds) -> impl ParallelIterator<Item = usize> + 'a {
-        match layer_ids {
-            LayerIds::None => LayerVariants::None(rayon::iter::empty()),
-            LayerIds::All => LayerVariants::All(
-                (0..self.internal_num_layers())
-                    .into_par_iter()
-                    .filter(move |&l| self.has_layer_inner(l)),
-            ),
-            LayerIds::One(id) => {
-                LayerVariants::One(self.has_layer_inner(*id).then_some(*id).into_par_iter())
-            }
-            LayerIds::Multiple(ids) => {
-                LayerVariants::Multiple(ids.par_iter().filter(move |&id| self.has_layer_inner(id)))
-            }
-        }
-    }
-
-    fn additions(self, layer_id: usize) -> TimeIndexRef<'a> {
-        TimeIndexRef::Ref(self.get_additions(layer_id).unwrap_or(&TimeIndex::Empty))
+    fn additions(self, layer_id: LayerId) -> storage::EdgeAdditions<'a> {
+        EdgeRefOps::layer_additions(self, layer_id)
     }
 
-    fn deletions(self, layer_id: usize) -> TimeIndexRef<'a> {
-        TimeIndexRef::Ref(self.get_deletions(layer_id).unwrap_or(&TimeIndex::Empty))
+    fn deletions(self, layer_id: LayerId) -> storage::EdgeDeletions<'a> {
+        EdgeRefOps::layer_deletions(self, layer_id)
     }
 
     #[inline(always)]
-    fn temporal_prop_layer(self, layer_id: usize, prop_id: usize) -> impl TPropOps<'a> + 'a {
-        self.props(layer_id)
-            .and_then(|props| props.temporal_prop(prop_id))
-            .unwrap_or(&TProp::Empty)
+    fn temporal_prop_layer(self, layer_id: LayerId, prop_id: usize) -> impl TPropOps<'a> + 'a {
+        EdgeRefOps::layer_t_prop(self, layer_id, prop_id)
     }
 
-    fn metadata_layer(self, layer_id: usize, prop_id: usize) -> Option<Prop> {
-        self.props(layer_id)
-            .and_then(|props| props.metadata(prop_id).cloned())
+    fn metadata_layer(self, layer_id: LayerId, prop_id: usize) -> Option<Prop> {
+        EdgeRefOps::c_prop(self, layer_id, prop_id)
     }
 }
diff --git a/raphtory-storage/src/graph/edges/edges.rs b/raphtory-storage/src/graph/edges/edges.rs
index 1ea6f8237f..c0d21506fc 100644
--- a/raphtory-storage/src/graph/edges/edges.rs
+++ b/raphtory-storage/src/graph/edges/edges.rs
@@ -1,84 +1,46 @@
 use super::{edge_entry::EdgeStorageEntry, unlocked::UnlockedEdges};
-use crate::graph::{
-    edges::{edge_ref::EdgeStorageRef, edge_storage_ops::EdgeStorageOps},
-    variants::storage_variants3::StorageVariants3,
-};
-use raphtory_api::core::entities::{LayerIds, EID};
-use raphtory_core::storage::raw_edges::LockedEdges;
+use raphtory_api::core::entities::{properties::meta::STATIC_GRAPH_LAYER_ID, LayerIds, EID};
 use rayon::iter::ParallelIterator;
 use std::sync::Arc;
+use storage::{utils::Iter2, EdgeEntryRef, Extension, ReadLockedEdges};
 
-#[cfg(feature = "storage")]
-use crate::disk::storage_interface::{edges::DiskEdges, edges_ref::DiskEdgesRef};
-use crate::graph::variants::storage_variants2::StorageVariants2;
-
-pub enum EdgesStorage {
-    Mem(Arc<LockedEdges>),
-    #[cfg(feature = "storage")]
-    Disk(DiskEdges),
+pub struct EdgesStorage {
+    storage: Arc<ReadLockedEdges<Extension>>,
 }
 
 impl EdgesStorage {
+    pub fn new(storage: Arc<ReadLockedEdges<Extension>>) -> Self {
+        Self { storage }
+    }
+
     #[inline]
     pub fn as_ref(&self) -> EdgesStorageRef<'_> {
-        match self {
-            EdgesStorage::Mem(storage) => EdgesStorageRef::Mem(storage),
-            #[cfg(feature = "storage")]
-            EdgesStorage::Disk(storage) => EdgesStorageRef::Disk(storage.as_ref()),
-        }
+        EdgesStorageRef::Mem(self.storage.as_ref())
     }
 
-    pub fn edge(&self, eid: EID) -> EdgeStorageRef<'_> {
-        match self {
-            EdgesStorage::Mem(storage) => EdgeStorageRef::Mem(storage.get_mem(eid)),
-            #[cfg(feature = "storage")]
-            EdgesStorage::Disk(storage) => EdgeStorageRef::Disk(storage.get(eid)),
-        }
+    pub fn edge(&self, eid: EID) -> EdgeEntryRef<'_> {
+        self.storage.edge_ref(eid)
     }
 
     pub fn iter<'a>(
         &'a self,
         layers: &'a LayerIds,
-    ) -> impl Iterator<Item = EdgeStorageRef<'a>> + Send + Sync + 'a {
-        match self {
-            EdgesStorage::Mem(storage) => {
-                StorageVariants2::Mem((0..storage.len()).map(EID).filter_map(|e| {
-                    let edge = storage.try_get_mem(e)?;
-                    edge.has_layer(layers).then_some(EdgeStorageRef::Mem(edge))
-                }))
-            }
-            #[cfg(feature = "storage")]
-            EdgesStorage::Disk(storage) => {
-                StorageVariants2::Disk(storage.as_ref().iter(layers).map(EdgeStorageRef::Disk))
-            }
-        }
+    ) -> impl Iterator<Item = EdgeEntryRef<'a>> + Send + Sync + 'a {
+        self.storage.iter(layers)
     }
 
     pub fn par_iter<'a>(
         &'a self,
         layers: &'a LayerIds,
-    ) -> impl ParallelIterator<Item = EdgeStorageRef<'a>> + Sync + 'a {
-        match self {
-            EdgesStorage::Mem(storage) => StorageVariants2::Mem(
-                storage
-                    .par_iter()
-                    .filter(|e| e.has_layer(layers))
-                    .map(EdgeStorageRef::Mem),
-            ),
-            #[cfg(feature = "storage")]
-            EdgesStorage::Disk(storage) => {
-                StorageVariants2::Disk(storage.as_ref().par_iter(layers).map(EdgeStorageRef::Disk))
-            }
-        }
+    ) -> impl ParallelIterator<Item = EdgeEntryRef<'a>> + Sync + 'a {
+        self.storage.par_iter(layers)
     }
 }
 
 #[derive(Debug, Copy, Clone)]
 pub enum EdgesStorageRef<'a> {
-    Mem(&'a LockedEdges),
+    Mem(&'a ReadLockedEdges<Extension>),
     Unlocked(UnlockedEdges<'a>),
-    #[cfg(feature = "storage")]
-    Disk(DiskEdgesRef<'a>),
 }
 
 impl<'a> EdgesStorageRef<'a> {
@@ -87,46 +49,32 @@ impl<'a> EdgesStorageRef<'a> {
         layers: &'a LayerIds,
     ) -> impl Iterator<Item = EdgeStorageEntry<'a>> + Send + Sync + 'a {
         match self {
-            EdgesStorageRef::Mem(storage) => StorageVariants3::Mem(
-                storage
-                    .iter()
-                    .filter(move |e| e.has_layer(layers))
-                    .map(EdgeStorageEntry::Mem),
-            ),
-            EdgesStorageRef::Unlocked(edges) => StorageVariants3::Unlocked(
-                edges
-                    .iter()
-                    .filter(move |e| e.as_mem_edge().has_layer(layers))
-                    .map(EdgeStorageEntry::Unlocked),
-            ),
-            #[cfg(feature = "storage")]
-            EdgesStorageRef::Disk(storage) => {
-                StorageVariants3::Disk(storage.iter(layers).map(EdgeStorageEntry::Disk))
+            EdgesStorageRef::Mem(storage) => {
+                Iter2::I1(storage.iter(layers).map(EdgeStorageEntry::Mem))
             }
+            EdgesStorageRef::Unlocked(edges) => Iter2::I2(edges.iter(layers)),
         }
     }
 
     pub fn par_iter(
         self,
-        layers: &LayerIds,
-    ) -> impl ParallelIterator<Item = EdgeStorageEntry<'a>> + use<'a, '_> {
+        layers: &'a LayerIds,
+    ) -> impl ParallelIterator<Item = EdgeStorageEntry<'a>> + use<'a> {
         match self {
-            EdgesStorageRef::Mem(storage) => StorageVariants3::Mem(
-                storage
-                    .par_iter()
-                    .filter(move |e| e.has_layer(layers))
-                    .map(EdgeStorageEntry::Mem),
-            ),
-            EdgesStorageRef::Unlocked(edges) => StorageVariants3::Unlocked(
-                edges
-                    .par_iter()
-                    .filter(move |e| e.as_mem_edge().has_layer(layers))
-                    .map(EdgeStorageEntry::Unlocked),
-            ),
-            #[cfg(feature = "storage")]
-            EdgesStorageRef::Disk(storage) => {
-                StorageVariants3::Disk(storage.par_iter(layers).map(EdgeStorageEntry::Disk))
+            EdgesStorageRef::Mem(storage) => {
+                Iter2::I1(storage.par_iter(layers).map(EdgeStorageEntry::Mem))
             }
+            EdgesStorageRef::Unlocked(edges) => Iter2::I2(edges.par_iter(layers)),
+        }
+    }
+
+    pub fn segmented_par_iter(
+        self,
+    ) -> Option<impl ParallelIterator<Item = (usize, impl Iterator<Item = EID> + use<'a>)> + 'a>
+    {
+        match self {
+            EdgesStorageRef::Mem(storage) => Some(storage.row_groups_par_iter()),
+            _ => None,
         }
     }
 
@@ -135,41 +83,32 @@ impl<'a> EdgesStorageRef<'a> {
         match self {
             EdgesStorageRef::Mem(storage) => match layers {
                 LayerIds::None => 0,
-                LayerIds::All => storage.len(),
-                _ => storage.par_iter().filter(|e| e.has_layer(layers)).count(),
+                LayerIds::All => storage.storage().num_edges(),
+                LayerIds::One(layer_id) => storage.storage().num_edges_layer(*layer_id),
+                _ => self.par_iter(layers).count(),
             },
             EdgesStorageRef::Unlocked(edges) => match layers {
                 LayerIds::None => 0,
-                LayerIds::All => edges.len(),
-                _ => edges
-                    .par_iter()
-                    .filter(|e| e.as_mem_edge().has_layer(layers))
-                    .count(),
+                LayerIds::One(layer_id) => edges.storage().num_edges_layer(*layer_id),
+                LayerIds::All => edges.storage().num_edges_layer(STATIC_GRAPH_LAYER_ID),
+                _ => self.par_iter(layers).count(),
             },
-            #[cfg(feature = "storage")]
-            EdgesStorageRef::Disk(storage) => storage.count(layers),
         }
     }
 
     #[inline]
     pub fn edge(self, edge: EID) -> EdgeStorageEntry<'a> {
         match self {
-            EdgesStorageRef::Mem(storage) => EdgeStorageEntry::Mem(storage.get_mem(edge)),
-            EdgesStorageRef::Unlocked(storage) => {
-                EdgeStorageEntry::Unlocked(storage.0.edge_entry(edge))
-            }
-            #[cfg(feature = "storage")]
-            EdgesStorageRef::Disk(storage) => EdgeStorageEntry::Disk(storage.edge(edge)),
+            EdgesStorageRef::Mem(storage) => EdgeStorageEntry::Mem(storage.edge_ref(edge)),
+            EdgesStorageRef::Unlocked(storage) => storage.edge(edge),
         }
     }
 
     #[inline]
     pub fn len(&self) -> usize {
         match self {
-            EdgesStorageRef::Mem(storage) => storage.len(),
-            EdgesStorageRef::Unlocked(storage) => storage.len(),
-            #[cfg(feature = "storage")]
-            EdgesStorageRef::Disk(storage) => storage.len(),
+            EdgesStorageRef::Mem(storage) => storage.storage().num_edges(),
+            EdgesStorageRef::Unlocked(storage) => storage.storage().num_edges(),
         }
     }
 }
diff --git a/raphtory-storage/src/graph/edges/unlocked.rs b/raphtory-storage/src/graph/edges/unlocked.rs
index 53f959a2ae..d316302f68 100644
--- a/raphtory-storage/src/graph/edges/unlocked.rs
+++ b/raphtory-storage/src/graph/edges/unlocked.rs
@@ -1,30 +1,68 @@
-use raphtory_api::core::entities::EID;
-use raphtory_core::{
-    entities::graph::tgraph_storage::GraphStorage, storage::raw_edges::EdgeRGuard,
-};
+use raphtory_api::core::entities::{properties::meta::STATIC_GRAPH_LAYER_ID, LayerId};
+use raphtory_api_macros::box_on_debug_lifetime;
+use raphtory_core::entities::{LayerIds, EID};
 use rayon::prelude::*;
+use storage::{pages::edge_store::EdgeStorageInner, utils::Iter4, Extension, Layer};
+
+use crate::graph::edges::edge_entry::EdgeStorageEntry;
 
 #[derive(Copy, Clone, Debug)]
-pub struct UnlockedEdges<'a>(pub(crate) &'a GraphStorage);
+pub struct UnlockedEdges<'a>(pub(crate) &'a Layer<Extension>);
 
 impl<'a> UnlockedEdges<'a> {
-    pub fn iter(self) -> impl Iterator<Item = EdgeRGuard<'a>> + 'a {
-        let storage = self.0;
-        (0..storage.edges_len())
-            .map(EID)
-            .filter_map(|eid| storage.try_edge_entry(eid))
+    pub fn storage(&self) -> &'a EdgeStorageInner<storage::ES<Extension>, Extension> {
+        self.0.edges()
+    }
+
+    pub fn edge(&self, e_id: EID) -> EdgeStorageEntry<'a> {
+        EdgeStorageEntry::Unlocked(self.0.edges().edge(e_id))
+    }
+
+    pub fn iter_layer(self, layer_id: LayerId) -> impl Iterator<Item = EdgeStorageEntry<'a>> + 'a {
+        self.0
+            .edges()
+            .iter(layer_id)
+            .map(EdgeStorageEntry::Unlocked)
+    }
+
+    #[box_on_debug_lifetime]
+    pub fn iter(
+        self,
+        layer_ids: &'a LayerIds,
+    ) -> impl Iterator<Item = EdgeStorageEntry<'a>> + Send + Sync + 'a {
+        match layer_ids {
+            LayerIds::None => Iter4::I(std::iter::empty()),
+            LayerIds::All => Iter4::J(self.iter_layer(LayerId(0))),
+            LayerIds::One(layer_id) => Iter4::K(self.iter_layer(*layer_id)),
+            LayerIds::Multiple(multiple) => Iter4::L(
+                self.iter_layer(LayerId(0))
+                    .filter(|edge| edge.as_ref().has_layers(multiple)),
+            ),
+        }
     }
 
-    pub fn par_iter(self) -> impl ParallelIterator<Item = EdgeRGuard<'a>> + 'a {
-        let storage = self.0;
-        (0..storage.edges_len())
-            .into_par_iter()
-            .map(EID)
-            .filter_map(|eid| storage.try_edge_entry(eid))
+    pub fn par_iter_layer(
+        self,
+        layer_id: LayerId,
+    ) -> impl ParallelIterator<Item = EdgeStorageEntry<'a>> + 'a {
+        self.0
+            .edges()
+            .par_iter(layer_id)
+            .map(EdgeStorageEntry::Unlocked)
     }
 
-    #[inline]
-    pub fn len(self) -> usize {
-        self.0.edges_len()
+    pub fn par_iter(
+        self,
+        layer_ids: &'a LayerIds,
+    ) -> impl ParallelIterator<Item = EdgeStorageEntry<'a>> + 'a {
+        match layer_ids {
+            LayerIds::None => Iter4::I(rayon::iter::empty()),
+            LayerIds::All => Iter4::J(self.par_iter_layer(STATIC_GRAPH_LAYER_ID)),
+            LayerIds::One(layer_id) => Iter4::K(self.par_iter_layer(*layer_id)),
+            LayerIds::Multiple(multiple) => Iter4::L(
+                self.par_iter_layer(STATIC_GRAPH_LAYER_ID)
+                    .filter(|edge| edge.as_ref().has_layers(multiple)),
+            ),
+        }
     }
 }
diff --git a/raphtory-storage/src/graph/graph.rs b/raphtory-storage/src/graph/graph.rs
index 3592ad6f2f..783e8130eb 100644
--- a/raphtory-storage/src/graph/graph.rs
+++ b/raphtory-storage/src/graph/graph.rs
@@ -2,56 +2,47 @@ use super::{
     edges::{edge_entry::EdgeStorageEntry, unlocked::UnlockedEdges},
     nodes::node_entry::NodeStorageEntry,
 };
-use crate::graph::{
-    edges::edges::{EdgesStorage, EdgesStorageRef},
-    locked::LockedGraph,
-    nodes::{nodes::NodesStorage, nodes_ref::NodesStorageEntry},
+use crate::{
+    graph::{
+        edges::edges::{EdgesStorage, EdgesStorageRef},
+        locked::LockedGraph,
+        nodes::{nodes::NodesStorage, nodes_ref::NodesStorageEntry},
+    },
+    mutation::MutationError,
 };
-use raphtory_api::core::entities::{properties::meta::Meta, LayerIds, LayerVariants, EID, VID};
-use raphtory_core::entities::{
-    graph::tgraph::TemporalGraph, nodes::node_ref::NodeRef, properties::graph_meta::GraphMeta,
+use db4_graph::TemporalGraph;
+use raphtory_api::core::entities::{
+    properties::meta::Meta, LayerId, LayerIds, LayerVariants, EID, VID,
 };
-use serde::{Deserialize, Serialize};
-use std::{fmt::Debug, iter, sync::Arc};
-use thiserror::Error;
-
-#[cfg(feature = "storage")]
-use crate::disk::{
-    storage_interface::{
-        edges::DiskEdges, edges_ref::DiskEdgesRef, node::DiskNode, nodes::DiskNodesOwned,
-        nodes_ref::DiskNodesRef,
-    },
-    DiskGraphStorage,
+use raphtory_core::entities::nodes::node_ref::NodeRef;
+use std::{fmt::Debug, iter, path::Path, sync::Arc};
+use storage::{
+    error::StorageError, pages::SegmentCounts, state::StateIndex, Extension, GIDResolver,
+    GraphPropEntry,
 };
-use crate::mutation::MutationError;
+use thiserror::Error;
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug)]
 pub enum GraphStorage {
     Mem(LockedGraph),
     Unlocked(Arc<TemporalGraph>),
-    #[cfg(feature = "storage")]
-    Disk(Arc<DiskGraphStorage>),
 }
 
 #[derive(Error, Debug)]
 pub enum Immutable {
     #[error("The graph is locked and cannot be mutated")]
     ReadLockedImmutable,
-    #[cfg(feature = "storage")]
-    #[error("DiskGraph cannot be mutated")]
-    DiskGraphImmutable,
 }
 
-impl From<TemporalGraph> for GraphStorage {
-    fn from(value: TemporalGraph) -> Self {
-        Self::Unlocked(Arc::new(value))
+impl From<Arc<TemporalGraph>> for GraphStorage {
+    fn from(value: Arc<TemporalGraph>) -> Self {
+        Self::Unlocked(value)
     }
 }
 
-#[cfg(feature = "storage")]
-impl From<DiskGraphStorage> for GraphStorage {
-    fn from(value: DiskGraphStorage) -> Self {
-        Self::Disk(Arc::new(value))
+impl From<TemporalGraph> for GraphStorage {
+    fn from(value: TemporalGraph) -> Self {
+        Self::Unlocked(Arc::new(value))
     }
 }
 
@@ -66,8 +57,8 @@ impl std::fmt::Display for GraphStorage {
         write!(
             f,
             "Graph(num_nodes={}, num_edges={})",
-            self.unfiltered_num_nodes(),
-            self.unfiltered_num_edges(),
+            self.unfiltered_num_nodes(&LayerIds::All),
+            self.unfiltered_num_edges(&LayerIds::All),
         )
     }
 }
@@ -84,13 +75,6 @@ impl GraphStorage {
                     graph: other_graph, ..
                 })
                 | GraphStorage::Unlocked(other_graph) => Arc::ptr_eq(this_graph, other_graph),
-                #[cfg(feature = "storage")]
-                _ => false,
-            },
-            #[cfg(feature = "storage")]
-            GraphStorage::Disk(this_graph) => match other {
-                GraphStorage::Disk(other_graph) => Arc::ptr_eq(this_graph, other_graph),
-                _ => false,
             },
         }
     }
@@ -99,8 +83,6 @@ impl GraphStorage {
         match self {
             GraphStorage::Mem(_) => Err(Immutable::ReadLockedImmutable)?,
             GraphStorage::Unlocked(graph) => Ok(graph),
-            #[cfg(feature = "storage")]
-            GraphStorage::Disk(_) => Err(Immutable::DiskGraphImmutable)?,
         }
     }
 
@@ -109,8 +91,6 @@ impl GraphStorage {
         match self {
             GraphStorage::Mem(_) => true,
             GraphStorage::Unlocked(_) => false,
-            #[cfg(feature = "storage")]
-            GraphStorage::Disk(_) => true,
         }
     }
 
@@ -125,20 +105,51 @@ impl GraphStorage {
         }
     }
 
+    pub fn flush(&self) -> Result<(), StorageError> {
+        match self {
+            GraphStorage::Mem(graph) => graph.flush(),
+            GraphStorage::Unlocked(graph) => graph.flush(),
+        }
+    }
+
+    pub fn disk_storage_path(&self) -> Option<&Path> {
+        match self {
+            GraphStorage::Mem(graph) => graph.graph.disk_storage_path(),
+            GraphStorage::Unlocked(graph) => graph.disk_storage_path(),
+        }
+    }
+
+    pub fn logical_to_physical(&self) -> &GIDResolver {
+        match self {
+            GraphStorage::Mem(graph) => &graph.graph.logical_to_physical,
+            GraphStorage::Unlocked(graph) => &graph.logical_to_physical,
+        }
+    }
+
     #[inline(always)]
     pub fn nodes(&self) -> NodesStorageEntry<'_> {
         match self {
             GraphStorage::Mem(storage) => NodesStorageEntry::Mem(&storage.nodes),
             GraphStorage::Unlocked(storage) => {
-                NodesStorageEntry::Unlocked(storage.storage.nodes.read_lock())
-            }
-            #[cfg(feature = "storage")]
-            GraphStorage::Disk(storage) => {
-                NodesStorageEntry::Disk(DiskNodesRef::new(&storage.inner))
+                NodesStorageEntry::Unlocked(storage.storage().nodes().locked())
             }
         }
     }
 
+    pub fn num_node_segments(&self) -> usize {
+        match self {
+            GraphStorage::Mem(storage) => storage.graph.storage().nodes().num_segments(),
+            GraphStorage::Unlocked(storage) => storage.storage().nodes().num_segments(),
+        }
+    }
+
+    pub fn num_edge_segments(&self) -> usize {
+        match self {
+            GraphStorage::Mem(storage) => storage.graph.storage().edges().num_segments(),
+            GraphStorage::Unlocked(storage) => storage.storage().edges().num_segments(),
+        }
+    }
+
     #[inline(always)]
     pub fn internalise_node(&self, v: NodeRef) -> Option<VID> {
         match v {
@@ -146,32 +157,23 @@ impl GraphStorage {
             node_ref => match self {
                 GraphStorage::Mem(locked) => locked.graph.resolve_node_ref(node_ref),
                 GraphStorage::Unlocked(unlocked) => unlocked.resolve_node_ref(node_ref),
-                #[cfg(feature = "storage")]
-                GraphStorage::Disk(storage) => match v {
-                    NodeRef::External(id) => storage.inner.find_node(id),
-                    _ => unreachable!("VID is handled above!"),
-                },
             },
         }
     }
 
     #[inline(always)]
-    pub fn unfiltered_num_nodes(&self) -> usize {
+    pub fn unfiltered_num_nodes(&self, layer_ids: &LayerIds) -> usize {
         match self {
-            GraphStorage::Mem(storage) => storage.nodes.len(),
-            GraphStorage::Unlocked(storage) => storage.internal_num_nodes(),
-            #[cfg(feature = "storage")]
-            GraphStorage::Disk(storage) => storage.inner.num_nodes(),
+            GraphStorage::Mem(storage) => storage.graph.internal_num_nodes(layer_ids),
+            GraphStorage::Unlocked(storage) => storage.internal_num_nodes(layer_ids),
         }
     }
 
     #[inline(always)]
-    pub fn unfiltered_num_edges(&self) -> usize {
+    pub fn unfiltered_num_edges(&self, layer_ids: &LayerIds) -> usize {
         match self {
-            GraphStorage::Mem(storage) => storage.edges.len(),
-            GraphStorage::Unlocked(storage) => storage.storage.edges_len(),
-            #[cfg(feature = "storage")]
-            GraphStorage::Disk(storage) => storage.inner.count_edges(),
+            GraphStorage::Mem(storage) => storage.graph.internal_num_edges(layer_ids),
+            GraphStorage::Unlocked(storage) => storage.internal_num_edges(layer_ids),
         }
     }
 
@@ -180,21 +182,15 @@ impl GraphStorage {
         match self {
             GraphStorage::Mem(storage) => storage.graph.num_layers(),
             GraphStorage::Unlocked(storage) => storage.num_layers(),
-            #[cfg(feature = "storage")]
-            GraphStorage::Disk(storage) => storage.inner.layers().len(),
         }
     }
 
     #[inline(always)]
     pub fn core_nodes(&self) -> NodesStorage {
         match self {
-            GraphStorage::Mem(storage) => NodesStorage::Mem(storage.nodes.clone()),
+            GraphStorage::Mem(storage) => NodesStorage::new(storage.nodes.clone()),
             GraphStorage::Unlocked(storage) => {
-                NodesStorage::Mem(LockedGraph::new(storage.clone()).nodes.clone())
-            }
-            #[cfg(feature = "storage")]
-            GraphStorage::Disk(storage) => {
-                NodesStorage::Disk(DiskNodesOwned::new(storage.inner.clone()))
+                NodesStorage::new(storage.read_locked().nodes.clone())
             }
         }
     }
@@ -202,13 +198,9 @@ impl GraphStorage {
     #[inline(always)]
     pub fn core_node<'a>(&'a self, vid: VID) -> NodeStorageEntry<'a> {
         match self {
-            GraphStorage::Mem(storage) => NodeStorageEntry::Mem(storage.nodes.get_entry(vid)),
+            GraphStorage::Mem(storage) => NodeStorageEntry::Mem(storage.nodes.node_ref(vid)),
             GraphStorage::Unlocked(storage) => {
-                NodeStorageEntry::Unlocked(storage.storage.get_node(vid))
-            }
-            #[cfg(feature = "storage")]
-            GraphStorage::Disk(storage) => {
-                NodeStorageEntry::Disk(DiskNode::new(&storage.inner, vid))
+                NodeStorageEntry::Unlocked(storage.storage().nodes().node(vid))
             }
         }
     }
@@ -217,21 +209,13 @@ impl GraphStorage {
     pub fn try_core_node<'a>(&'a self, vid: VID) -> Option<NodeStorageEntry<'a>> {
         match self {
             GraphStorage::Mem(storage) => {
-                storage.nodes.try_get_entry(vid).map(NodeStorageEntry::Mem)
+                storage.nodes.try_node_ref(vid).map(NodeStorageEntry::Mem)
             }
             GraphStorage::Unlocked(storage) => storage
-                .storage
-                .nodes
-                .try_entry(vid)
+                .storage()
+                .nodes()
+                .try_node(vid)
                 .map(NodeStorageEntry::Unlocked),
-            #[cfg(feature = "storage")]
-            GraphStorage::Disk(storage) => {
-                if vid.index() < storage.inner().num_nodes() {
-                    Some(NodeStorageEntry::Disk(DiskNode::new(storage.inner(), vid)))
-                } else {
-                    None
-                }
-            }
         }
     }
 
@@ -240,449 +224,96 @@ impl GraphStorage {
         match self {
             GraphStorage::Mem(storage) => EdgesStorageRef::Mem(&storage.edges),
             GraphStorage::Unlocked(storage) => {
-                EdgesStorageRef::Unlocked(UnlockedEdges(&storage.storage))
+                EdgesStorageRef::Unlocked(UnlockedEdges(storage.storage()))
             }
-            #[cfg(feature = "storage")]
-            GraphStorage::Disk(storage) => EdgesStorageRef::Disk(DiskEdgesRef::new(&storage.inner)),
         }
     }
 
     #[inline(always)]
     pub fn owned_edges(&self) -> EdgesStorage {
         match self {
-            GraphStorage::Mem(storage) => EdgesStorage::Mem(storage.edges.clone()),
+            GraphStorage::Mem(storage) => EdgesStorage::new(storage.edges.clone()),
             GraphStorage::Unlocked(storage) => {
-                GraphStorage::Mem(LockedGraph::new(storage.clone())).owned_edges()
+                EdgesStorage::new(storage.storage().edges().locked().into())
             }
-            #[cfg(feature = "storage")]
-            GraphStorage::Disk(storage) => EdgesStorage::Disk(DiskEdges::new(storage)),
         }
     }
 
     #[inline(always)]
     pub fn edge_entry(&self, eid: EID) -> EdgeStorageEntry<'_> {
         match self {
-            GraphStorage::Mem(storage) => EdgeStorageEntry::Mem(storage.edges.get_mem(eid)),
+            GraphStorage::Mem(storage) => EdgeStorageEntry::Mem(storage.edges.edge_ref(eid)),
             GraphStorage::Unlocked(storage) => {
-                EdgeStorageEntry::Unlocked(storage.storage.edge_entry(eid))
+                EdgeStorageEntry::Unlocked(storage.storage().edges().edge(eid))
             }
-            #[cfg(feature = "storage")]
-            GraphStorage::Disk(storage) => EdgeStorageEntry::Disk(storage.inner.edge(eid)),
         }
     }
 
-    pub fn layer_ids_iter(&self, layer_ids: &LayerIds) -> impl Iterator<Item = usize> {
+    /// Acquired a locked, read-only view of graph properties / metadata.
+    #[inline(always)]
+    pub fn graph_entry(&self) -> GraphPropEntry<'_> {
+        match self {
+            GraphStorage::Mem(storage) => storage.graph.storage().graph_props().graph_entry(),
+            GraphStorage::Unlocked(storage) => storage.storage().graph_props().graph_entry(),
+        }
+    }
+
+    pub fn layer_ids_iter(&self, layer_ids: &LayerIds) -> impl Iterator<Item = LayerId> {
         match layer_ids {
             LayerIds::None => LayerVariants::None(iter::empty()),
-            LayerIds::All => LayerVariants::All(0..self.unfiltered_num_layers()),
+            LayerIds::All => LayerVariants::All((1..=self.unfiltered_num_layers()).map(LayerId)),
             LayerIds::One(id) => LayerVariants::One(iter::once(*id)),
-            LayerIds::Multiple(ids) => LayerVariants::Multiple(ids.into_iter()),
+            LayerIds::Multiple(ids) => LayerVariants::Multiple(ids.clone().into_iter()),
         }
     }
-    //
-    // pub fn into_nodes_iter<'graph, G: GraphViewOps<'graph>>(
-    //     self,
-    //     view: G,
-    //     node_list: NodeList,
-    //     type_filter: Option<Arc<[bool]>>,
-    // ) -> BoxedLIter<'graph, VID> {
-    //     node_list
-    //         .into_iter()
-    //         .filter(move |&vid| {
-    //             let node = self.node_entry(vid);
-    //             type_filter
-    //                 .as_ref()
-    //                 .map_or(true, |type_filter| type_filter[node.node_type_id()])
-    //                 && view.filter_node(node.as_ref())
-    //         })
-    //         .into_dyn_boxed()
-    // }
-    //
-    // pub fn nodes_par<'a, 'graph: 'a, G: GraphViewOps<'graph>>(
-    //     &'a self,
-    //     view: &'a G,
-    //     type_filter: Option<&'a Arc<[bool]>>,
-    // ) -> impl ParallelIterator<Item = VID> + 'a {
-    //     let nodes = self.nodes();
-    //     view.node_list().into_par_iter().filter(move |&vid| {
-    //         let node = nodes.node(vid);
-    //         type_filter.map_or(true, |type_filter| type_filter[node.node_type_id()])
-    //             && view.filter_node(node)
-    //     })
-    // }
-    //
-    // pub fn into_nodes_par<'graph, G: GraphViewOps<'graph>>(
-    //     self,
-    //     view: G,
-    //     node_list: NodeList,
-    //     type_filter: Option<Arc<[bool]>>,
-    // ) -> impl ParallelIterator<Item = VID> + 'graph {
-    //     node_list.into_par_iter().filter(move |&vid| {
-    //         let node = self.node_entry(vid);
-    //         type_filter
-    //             .as_ref()
-    //             .map_or(true, |type_filter| type_filter[node.node_type_id()])
-    //             && view.filter_node(node.as_ref())
-    //     })
-    // }
-    //
-    // pub fn edges_iter<'graph, G: GraphViewOps<'graph>>(
-    //     &'graph self,
-    //     view: &'graph G,
-    // ) -> impl Iterator<Item = EdgeRef> + Send + 'graph {
-    //     let iter = self.edges().iter(view.layer_ids());
-    //
-    //     let filtered = match view.filter_state() {
-    //         FilterState::Neither => FilterVariants::Neither(iter),
-    //         FilterState::Both => {
-    //             let nodes = self.nodes();
-    //             FilterVariants::Both(iter.filter(move |e| {
-    //                 view.filter_edge(e.as_ref(), view.layer_ids())
-    //                     && view.filter_node(nodes.node(e.src()))
-    //                     && view.filter_node(nodes.node(e.dst()))
-    //             }))
-    //         }
-    //         FilterState::Nodes => {
-    //             let nodes = self.nodes();
-    //             FilterVariants::Nodes(iter.filter(move |e| {
-    //                 view.filter_node(nodes.node(e.src())) && view.filter_node(nodes.node(e.dst()))
-    //             }))
-    //         }
-    //         FilterState::Edges | FilterState::BothIndependent => FilterVariants::Edges(
-    //             iter.filter(|e| view.filter_edge(e.as_ref(), view.layer_ids())),
-    //         ),
-    //     };
-    //     filtered.map(|e| e.out_ref())
-    // }
-    //
-    // pub fn into_edges_iter<'graph, G: GraphViewOps<'graph>>(
-    //     self,
-    //     view: G,
-    // ) -> impl Iterator<Item = EdgeRef> + Send + 'graph {
-    //     match view.node_list() {
-    //         NodeList::List { elems } => {
-    //             return elems
-    //                 .into_iter()
-    //                 .flat_map(move |v| {
-    //                     self.clone()
-    //                         .into_node_edges_iter(v, Direction::OUT, view.clone())
-    //                 })
-    //                 .into_dyn_boxed()
-    //         }
-    //         _ => {}
-    //     }
-    //     let edges = self.owned_edges();
-    //     let nodes = self.owned_nodes();
-    //
-    //     match edges {
-    //         EdgesStorage::Mem(edges) => {
-    //             let iter = (0..edges.len()).map(EID);
-    //             let filtered = match view.filter_state() {
-    //                 FilterState::Neither => {
-    //                     FilterVariants::Neither(iter.map(move |eid| edges.get_mem(eid).out_ref()))
-    //                 }
-    //                 FilterState::Both => FilterVariants::Both(iter.filter_map(move |e| {
-    //                     let e = EdgeStorageRef::Mem(edges.get_mem(e));
-    //                     (view.filter_edge(e, view.layer_ids())
-    //                         && view.filter_node(nodes.node_entry(e.src()))
-    //                         && view.filter_node(nodes.node_entry(e.dst())))
-    //                     .then(|| e.out_ref())
-    //                 })),
-    //                 FilterState::Nodes => FilterVariants::Nodes(iter.filter_map(move |e| {
-    //                     let e = EdgeStorageRef::Mem(edges.get_mem(e));
-    //                     (view.filter_node(nodes.node_entry(e.src()))
-    //                         && view.filter_node(nodes.node_entry(e.dst())))
-    //                     .then(|| e.out_ref())
-    //                 })),
-    //                 FilterState::Edges | FilterState::BothIndependent => {
-    //                     FilterVariants::Edges(iter.filter_map(move |e| {
-    //                         let e = EdgeStorageRef::Mem(edges.get_mem(e));
-    //                         view.filter_edge(e, view.layer_ids()).then(|| e.out_ref())
-    //                     }))
-    //                 }
-    //             };
-    //             filtered.into_dyn_boxed()
-    //         }
-    //         #[cfg(feature = "storage")]
-    //         EdgesStorage::Disk(edges) => {
-    //             let edges_clone = edges.clone();
-    //             let iter = edges_clone.into_iter_refs(view.layer_ids().clone());
-    //             let filtered = match view.filter_state() {
-    //                 FilterState::Neither => FilterVariants::Neither(iter),
-    //                 FilterState::Both => FilterVariants::Both(iter.filter_map(move |e| {
-    //                     let edge = EdgeStorageRef::Disk(edges.get(e.pid()));
-    //                     if !view.filter_edge(edge, view.layer_ids()) {
-    //                         return None;
-    //                     }
-    //                     let src = nodes.node_entry(e.src());
-    //                     if !view.filter_node(src) {
-    //                         return None;
-    //                     }
-    //                     let dst = nodes.node_entry(e.dst());
-    //                     if !view.filter_node(dst) {
-    //                         return None;
-    //                     }
-    //                     Some(e)
-    //                 })),
-    //                 FilterState::Nodes => FilterVariants::Nodes(iter.filter_map(move |e| {
-    //                     let src = nodes.node_entry(e.src());
-    //                     if !view.filter_node(src) {
-    //                         return None;
-    //                     }
-    //                     let dst = nodes.node_entry(e.dst());
-    //                     if !view.filter_node(dst) {
-    //                         return None;
-    //                     }
-    //                     Some(e)
-    //                 })),
-    //                 FilterState::Edges | FilterState::BothIndependent => {
-    //                     FilterVariants::Edges(iter.filter_map(move |e| {
-    //                         let edge = EdgeStorageRef::Disk(edges.get(e.pid()));
-    //                         if !view.filter_edge(edge, view.layer_ids()) {
-    //                             return None;
-    //                         }
-    //                         Some(e)
-    //                     }))
-    //                 }
-    //             };
-    //             filtered.into_dyn_boxed()
-    //         }
-    //     }
-    // }
-    //
-    // pub fn edges_par<'graph, G: GraphViewOps<'graph>>(
-    //     &'graph self,
-    //     view: &'graph G,
-    // ) -> impl ParallelIterator<Item = EdgeRef> + 'graph {
-    //     self.edges()
-    //         .par_iter(view.layer_ids())
-    //         .filter(|edge| match view.filter_state() {
-    //             FilterState::Neither => true,
-    //             FilterState::Both => {
-    //                 let src = self.node_entry(edge.src());
-    //                 let dst = self.node_entry(edge.dst());
-    //                 view.filter_edge(edge.as_ref(), view.layer_ids())
-    //                     && view.filter_node(src.as_ref())
-    //                     && view.filter_node(dst.as_ref())
-    //             }
-    //             FilterState::Nodes => {
-    //                 let src = self.node_entry(edge.src());
-    //                 let dst = self.node_entry(edge.dst());
-    //                 view.filter_node(src.as_ref()) && view.filter_node(dst.as_ref())
-    //             }
-    //             FilterState::Edges | FilterState::BothIndependent => {
-    //                 view.filter_edge(edge.as_ref(), view.layer_ids())
-    //             }
-    //         })
-    //         .map(|e| e.out_ref())
-    // }
-    //
-    // pub fn into_edges_par<'graph, G: GraphViewOps<'graph>>(
-    //     self,
-    //     view: G,
-    // ) -> impl ParallelIterator<Item = EdgeRef> + 'graph {
-    //     let edges = self.owned_edges();
-    //     let nodes = self.owned_nodes();
-    //
-    //     match edges {
-    //         EdgesStorage::Mem(edges) => {
-    //             let iter = (0..edges.len()).into_par_iter().map(EID);
-    //             let filtered = match view.filter_state() {
-    //                 FilterState::Neither => FilterVariants::Neither(
-    //                     iter.map(move |eid| edges.get_mem(eid).as_edge_ref()),
-    //                 ),
-    //                 FilterState::Both => FilterVariants::Both(iter.filter_map(move |e| {
-    //                     let e = EdgeStorageRef::Mem(edges.get_mem(e));
-    //                     (view.filter_edge(e, view.layer_ids())
-    //                         && view.filter_node(nodes.node_entry(e.src()))
-    //                         && view.filter_node(nodes.node_entry(e.dst())))
-    //                     .then(|| e.out_ref())
-    //                 })),
-    //                 FilterState::Nodes => FilterVariants::Nodes(iter.filter_map(move |e| {
-    //                     let e = EdgeStorageRef::Mem(edges.get_mem(e));
-    //                     (view.filter_node(nodes.node_entry(e.src()))
-    //                         && view.filter_node(nodes.node_entry(e.dst())))
-    //                     .then(|| e.out_ref())
-    //                 })),
-    //                 FilterState::Edges | FilterState::BothIndependent => {
-    //                     FilterVariants::Edges(iter.filter_map(move |e| {
-    //                         let e = EdgeStorageRef::Mem(edges.get_mem(e));
-    //                         view.filter_edge(e, view.layer_ids()).then(|| e.out_ref())
-    //                     }))
-    //                 }
-    //             };
-    //             #[cfg(feature = "storage")]
-    //             {
-    //                 StorageVariants::Mem(filtered)
-    //             }
-    //             #[cfg(not(feature = "storage"))]
-    //             {
-    //                 filtered
-    //             }
-    //         }
-    //         #[cfg(feature = "storage")]
-    //         EdgesStorage::Disk(edges) => {
-    //             let edges_clone = edges.clone();
-    //             let iter = edges_clone.into_par_iter_refs(view.layer_ids().clone());
-    //             let filtered = match view.filter_state() {
-    //                 FilterState::Neither => FilterVariants::Neither(
-    //                     iter.map(move |eid| EdgeStorageRef::Disk(edges.get(eid)).out_ref()),
-    //                 ),
-    //                 FilterState::Both => FilterVariants::Both(iter.filter_map(move |eid| {
-    //                     let e = EdgeStorageRef::Disk(edges.get(eid));
-    //                     if !view.filter_edge(e, view.layer_ids()) {
-    //                         return None;
-    //                     }
-    //                     let src = nodes.node_entry(e.src());
-    //                     if !view.filter_node(src) {
-    //                         return None;
-    //                     }
-    //                     let dst = nodes.node_entry(e.dst());
-    //                     if !view.filter_node(dst) {
-    //                         return None;
-    //                     }
-    //                     Some(e.out_ref())
-    //                 })),
-    //                 FilterState::Nodes => FilterVariants::Nodes(iter.filter_map(move |eid| {
-    //                     let e = EdgeStorageRef::Disk(edges.get(eid));
-    //                     let src = nodes.node_entry(e.src());
-    //                     if !view.filter_node(src) {
-    //                         return None;
-    //                     }
-    //                     let dst = nodes.node_entry(e.dst());
-    //                     if !view.filter_node(dst) {
-    //                         return None;
-    //                     }
-    //                     Some(e.out_ref())
-    //                 })),
-    //                 FilterState::Edges | FilterState::BothIndependent => {
-    //                     FilterVariants::Edges(iter.filter_map(move |eid| {
-    //                         let e = EdgeStorageRef::Disk(edges.get(eid));
-    //                         if !view.filter_edge(e, view.layer_ids()) {
-    //                             return None;
-    //                         }
-    //                         Some(e.out_ref())
-    //                     }))
-    //                 }
-    //             };
-    //             StorageVariants::Disk(filtered)
-    //         }
-    //     }
-    // }
-    //
-    // pub fn node_neighbours_iter<'a, 'graph: 'a, G: GraphViewOps<'graph>>(
-    //     &'a self,
-    //     node: VID,
-    //     dir: Direction,
-    //     view: &'a G,
-    // ) -> impl Iterator<Item = VID> + Send + 'a {
-    //     self.node_edges_iter(node, dir, view)
-    //         .map(|e| e.remote())
-    //         .dedup()
-    // }
-    //
-    // pub fn into_node_neighbours_iter<'graph, G: GraphViewOps<'graph>>(
-    //     self,
-    //     node: VID,
-    //     dir: Direction,
-    //     view: G,
-    // ) -> impl Iterator<Item = VID> + 'graph {
-    //     self.into_node_edges_iter(node, dir, view)
-    //         .map(|e| e.remote())
-    //         .dedup()
-    // }
-    //
-    // #[inline]
-    // pub fn node_degree<'graph, G: GraphViewOps<'graph>>(
-    //     &self,
-    //     node: VID,
-    //     dir: Direction,
-    //     view: &G,
-    // ) -> usize {
-    //     if matches!(view.filter_state(), FilterState::Neither) {
-    //         self.node_entry(node).degree(view.layer_ids(), dir)
-    //     } else {
-    //         self.node_neighbours_iter(node, dir, view).count()
-    //     }
-    // }
-    //
-    // pub fn node_edges_iter<'a, 'graph: 'a, G: GraphViewOps<'graph>>(
-    //     &'a self,
-    //     node: VID,
-    //     dir: Direction,
-    //     view: &'a G,
-    // ) -> impl Iterator<Item = EdgeRef> + 'a {
-    //     let source = self.node_entry(node);
-    //     let layers = view.layer_ids();
-    //     let iter = source.into_edges_iter(layers, dir);
-    //     match view.filter_state() {
-    //         FilterState::Neither => FilterVariants::Neither(iter),
-    //         FilterState::Both => FilterVariants::Both(iter.filter(|&e| {
-    //             view.filter_edge(self.edge_entry(e.pid()).as_ref(), view.layer_ids())
-    //                 && view.filter_node(self.node_entry(e.remote()).as_ref())
-    //         })),
-    //         FilterState::Nodes => FilterVariants::Nodes(
-    //             iter.filter(|e| view.filter_node(self.node_entry(e.remote()).as_ref())),
-    //         ),
-    //         FilterState::Edges | FilterState::BothIndependent => {
-    //             FilterVariants::Edges(iter.filter(|&e| {
-    //                 view.filter_edge(self.edge_entry(e.pid()).as_ref(), view.layer_ids())
-    //             }))
-    //         }
-    //     }
-    // }
-    //
-    // pub fn into_node_edges_iter<'graph, G: GraphViewOps<'graph>>(
-    //     self,
-    //     node: VID,
-    //     dir: Direction,
-    //     view: G,
-    // ) -> impl Iterator<Item = EdgeRef> + 'graph {
-    //     let layers = view.layer_ids().clone();
-    //     let local = self.owned_node(node);
-    //     let iter = local.into_edges_iter(layers, dir);
-    //
-    //     match view.filter_state() {
-    //         FilterState::Neither => FilterVariants::Neither(iter),
-    //         FilterState::Both => FilterVariants::Both(iter.filter(move |&e| {
-    //             view.filter_edge(self.edge_entry(e.pid()).as_ref(), view.layer_ids())
-    //                 && view.filter_node(self.node_entry(e.remote()).as_ref())
-    //         })),
-    //         FilterState::Nodes => FilterVariants::Nodes(
-    //             iter.filter(move |e| view.filter_node(self.node_entry(e.remote()).as_ref())),
-    //         ),
-    //         FilterState::Edges | FilterState::BothIndependent => {
-    //             FilterVariants::Edges(iter.filter(move |&e| {
-    //                 view.filter_edge(self.edge_entry(e.pid()).as_ref(), view.layer_ids())
-    //             }))
-    //         }
-    //     }
-    // }
+
+    pub fn unfiltered_layer_ids(&self) -> impl Iterator<Item = LayerId> {
+        (1..=self.unfiltered_num_layers()).map(move |layer_id| LayerId(layer_id))
+    }
 
     pub fn node_meta(&self) -> &Meta {
         match self {
-            GraphStorage::Mem(storage) => &storage.graph.node_meta,
-            GraphStorage::Unlocked(storage) => &storage.node_meta,
-            #[cfg(feature = "storage")]
-            GraphStorage::Disk(storage) => storage.node_meta(),
+            GraphStorage::Mem(storage) => storage.graph.node_meta(),
+            GraphStorage::Unlocked(storage) => storage.node_meta(),
         }
     }
 
     pub fn edge_meta(&self) -> &Meta {
         match self {
-            GraphStorage::Mem(storage) => &storage.graph.edge_meta,
-            GraphStorage::Unlocked(storage) => &storage.edge_meta,
-            #[cfg(feature = "storage")]
-            GraphStorage::Disk(storage) => storage.edge_meta(),
+            GraphStorage::Mem(storage) => storage.graph.edge_meta(),
+            GraphStorage::Unlocked(storage) => storage.edge_meta(),
         }
     }
 
-    pub fn graph_meta(&self) -> &GraphMeta {
+    pub fn graph_props_meta(&self) -> &Meta {
+        match self {
+            GraphStorage::Mem(storage) => storage.graph.graph_props_meta(),
+            GraphStorage::Unlocked(storage) => storage.graph_props_meta(),
+        }
+    }
+
+    pub fn extension(&self) -> &Extension {
+        match self {
+            GraphStorage::Mem(storage) => storage.graph.extension(),
+            GraphStorage::Unlocked(storage) => storage.extension(),
+        }
+    }
+
+    pub fn node_segment_counts(&self) -> SegmentCounts<VID> {
+        match self {
+            GraphStorage::Mem(storage) => storage.nodes.segment_counts(),
+            GraphStorage::Unlocked(storage) => storage.storage().node_segment_counts(),
+        }
+    }
+
+    pub fn node_state_index(&self) -> StateIndex<VID> {
+        self.node_segment_counts().into()
+    }
+
+    pub fn edge_segment_counts(&self) -> SegmentCounts<EID> {
         match self {
-            GraphStorage::Mem(storage) => &storage.graph.graph_meta,
-            GraphStorage::Unlocked(storage) => &storage.graph_meta,
-            #[cfg(feature = "storage")]
-            GraphStorage::Disk(storage) => storage.graph_meta(),
+            GraphStorage::Mem(storage) => storage.edges.segment_counts(),
+            GraphStorage::Unlocked(storage) => storage.storage().edge_segment_counts(),
         }
     }
 }
diff --git a/raphtory-storage/src/graph/locked.rs b/raphtory-storage/src/graph/locked.rs
index 816c955217..59300e9091 100644
--- a/raphtory-storage/src/graph/locked.rs
+++ b/raphtory-storage/src/graph/locked.rs
@@ -1,51 +1,28 @@
-use raphtory_api::core::{
-    entities::{GidRef, VID},
-    storage::dict_mapper::MaybeNew,
-};
-use raphtory_core::{
-    entities::graph::{logical_to_physical::InvalidNodeId, tgraph::TemporalGraph},
-    storage::{
-        raw_edges::{LockedEdges, WriteLockedEdges},
-        ReadLockedStorage, WriteLockedNodes,
-    },
-};
+use db4_graph::TemporalGraph;
 use std::sync::Arc;
+use storage::{error::StorageError, Extension, ReadLockedEdges, ReadLockedNodes};
 
 #[derive(Debug)]
 pub struct LockedGraph {
-    pub(crate) nodes: Arc<ReadLockedStorage>,
-    pub(crate) edges: Arc<LockedEdges>,
+    pub(crate) nodes: Arc<ReadLockedNodes<Extension>>,
+    pub(crate) edges: Arc<ReadLockedEdges<Extension>>,
     pub graph: Arc<TemporalGraph>,
 }
 
-impl<'de> serde::Deserialize<'de> for LockedGraph {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        TemporalGraph::deserialize(deserializer).map(|graph| LockedGraph::new(Arc::new(graph)))
-    }
-}
-
-impl serde::Serialize for LockedGraph {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        self.graph.serialize(serializer)
-    }
-}
-
 impl LockedGraph {
     pub fn new(graph: Arc<TemporalGraph>) -> Self {
-        let nodes = Arc::new(graph.storage.nodes_read_lock());
-        let edges = Arc::new(graph.storage.edges_read_lock());
+        let nodes = Arc::new(graph.storage().nodes().locked());
+        let edges = Arc::new(graph.storage().edges().locked());
         Self {
             nodes,
             edges,
             graph,
         }
     }
+
+    pub fn flush(&self) -> Result<(), StorageError> {
+        self.graph.flush()
+    }
 }
 
 impl Clone for LockedGraph {
@@ -57,48 +34,3 @@ impl Clone for LockedGraph {
         }
     }
 }
-
-pub struct WriteLockedGraph<'a> {
-    pub nodes: WriteLockedNodes<'a>,
-    pub edges: WriteLockedEdges<'a>,
-    pub graph: &'a TemporalGraph,
-}
-
-impl<'a> WriteLockedGraph<'a> {
-    pub(crate) fn new(graph: &'a TemporalGraph) -> Self {
-        let nodes = graph.storage.nodes.write_lock();
-        let edges = graph.storage.edges.write_lock();
-        Self {
-            nodes,
-            edges,
-            graph,
-        }
-    }
-
-    pub fn num_nodes(&self) -> usize {
-        self.graph.storage.nodes.len()
-    }
-    pub fn resolve_node(&self, gid: GidRef) -> Result<MaybeNew<VID>, InvalidNodeId> {
-        self.graph
-            .logical_to_physical
-            .get_or_init(gid, || self.graph.storage.nodes.next_id())
-    }
-
-    pub fn resolve_node_type(&self, node_type: Option<&str>) -> MaybeNew<usize> {
-        node_type
-            .map(|node_type| self.graph.node_meta.get_or_create_node_type_id(node_type))
-            .unwrap_or_else(|| MaybeNew::Existing(0))
-    }
-
-    pub fn num_shards(&self) -> usize {
-        self.nodes.num_shards().max(self.edges.num_shards())
-    }
-
-    pub fn edges_mut(&mut self) -> &mut WriteLockedEdges<'a> {
-        &mut self.edges
-    }
-
-    pub fn graph(&self) -> &TemporalGraph {
-        self.graph
-    }
-}
diff --git a/raphtory-storage/src/graph/nodes/mod.rs b/raphtory-storage/src/graph/nodes/mod.rs
index 18fcc48daf..155a4f661d 100644
--- a/raphtory-storage/src/graph/nodes/mod.rs
+++ b/raphtory-storage/src/graph/nodes/mod.rs
@@ -1,7 +1,5 @@
-pub mod node_additions;
 pub mod node_entry;
 pub mod node_ref;
 pub mod node_storage_ops;
 pub mod nodes;
 pub mod nodes_ref;
-pub mod row;
diff --git a/raphtory-storage/src/graph/nodes/node_additions.rs b/raphtory-storage/src/graph/nodes/node_additions.rs
deleted file mode 100644
index bb66b7e52d..0000000000
--- a/raphtory-storage/src/graph/nodes/node_additions.rs
+++ /dev/null
@@ -1,209 +0,0 @@
-use iter_enum::{DoubleEndedIterator, ExactSizeIterator, FusedIterator, Iterator};
-use raphtory_api::core::{
-    entities::ELID,
-    storage::timeindex::{EventTime, TimeIndexOps},
-};
-use raphtory_core::{
-    entities::nodes::node_store::NodeTimestamps,
-    storage::timeindex::{TimeIndexWindow, TimeIndexWindowVariants},
-};
-use std::{iter, ops::Range};
-
-#[cfg(feature = "storage")]
-use {itertools::Itertools, pometry_storage::timestamps::LayerAdditions};
-
-#[derive(Clone, Debug)]
-pub enum NodeAdditions<'a> {
-    Mem(&'a NodeTimestamps),
-    Range(TimeIndexWindow<'a, EventTime, NodeTimestamps>),
-    #[cfg(feature = "storage")]
-    Col(LayerAdditions<'a>),
-}
-
-#[derive(Iterator, DoubleEndedIterator, ExactSizeIterator, FusedIterator, Debug)]
-pub enum AdditionVariants<Mem, Range, #[cfg(feature = "storage")] Col> {
-    Mem(Mem),
-    Range(Range),
-    #[cfg(feature = "storage")]
-    Col(Col),
-}
-
-impl<'a> NodeAdditions<'a> {
-    #[inline]
-    pub fn prop_events(&self) -> impl Iterator<Item = EventTime> + use<'a> {
-        match self {
-            NodeAdditions::Mem(index) => {
-                AdditionVariants::Mem(index.props_ts.iter().map(|(t, _)| *t))
-            }
-            NodeAdditions::Range(index) => AdditionVariants::Range(match index {
-                TimeIndexWindow::Empty => TimeIndexWindowVariants::Empty(iter::empty()),
-                TimeIndexWindow::Range { timeindex, range } => TimeIndexWindowVariants::Range(
-                    timeindex
-                        .props_ts
-                        .iter_window(range.clone())
-                        .map(|(t, _)| *t),
-                ),
-                TimeIndexWindow::All(index) => {
-                    TimeIndexWindowVariants::All(index.props_ts.iter().map(|(t, _)| *t))
-                }
-            }),
-            #[cfg(feature = "storage")]
-            NodeAdditions::Col(index) => {
-                AdditionVariants::Col(index.clone().prop_events().map(|t| t.into_iter()).kmerge())
-            }
-        }
-    }
-
-    #[inline]
-    pub fn prop_events_rev(&self) -> impl Iterator<Item = EventTime> + use<'a> {
-        match self {
-            NodeAdditions::Mem(index) => {
-                AdditionVariants::Mem(index.props_ts.iter().map(|(t, _)| *t).rev())
-            }
-            NodeAdditions::Range(index) => AdditionVariants::Range(match index {
-                TimeIndexWindow::Empty => TimeIndexWindowVariants::Empty(iter::empty()),
-                TimeIndexWindow::Range { timeindex, range } => TimeIndexWindowVariants::Range(
-                    timeindex
-                        .props_ts
-                        .iter_window(range.clone())
-                        .map(|(t, _)| *t)
-                        .rev(),
-                ),
-                TimeIndexWindow::All(index) => {
-                    TimeIndexWindowVariants::All(index.props_ts.iter().map(|(t, _)| *t).rev())
-                }
-            }),
-            #[cfg(feature = "storage")]
-            NodeAdditions::Col(index) => AdditionVariants::Col(
-                index
-                    .clone()
-                    .prop_events()
-                    .map(|t| t.into_iter().rev())
-                    .kmerge_by(|t1, t2| t1 >= t2),
-            ),
-        }
-    }
-
-    #[inline]
-    pub fn edge_events(&self) -> impl Iterator<Item = (EventTime, ELID)> + use<'a> {
-        match self {
-            NodeAdditions::Mem(index) => {
-                AdditionVariants::Mem(index.edge_ts.iter().map(|(t, e)| (*t, *e)))
-            }
-            NodeAdditions::Range(index) => AdditionVariants::Range(match index {
-                TimeIndexWindow::Empty => TimeIndexWindowVariants::Empty(iter::empty()),
-                TimeIndexWindow::Range { timeindex, range } => TimeIndexWindowVariants::Range(
-                    timeindex
-                        .edge_ts
-                        .iter_window(range.clone())
-                        .map(|(t, e)| (*t, *e)),
-                ),
-                TimeIndexWindow::All(index) => {
-                    TimeIndexWindowVariants::All(index.edge_ts.iter().map(|(t, e)| (*t, *e)))
-                }
-            }),
-            #[cfg(feature = "storage")]
-            NodeAdditions::Col(index) => AdditionVariants::Col(index.edge_history()),
-        }
-    }
-
-    #[inline]
-    pub fn edge_events_rev(&self) -> impl Iterator<Item = (EventTime, ELID)> + use<'a> {
-        match self {
-            NodeAdditions::Mem(index) => {
-                AdditionVariants::Mem(index.edge_ts.iter().map(|(t, e)| (*t, *e)).rev())
-            }
-            NodeAdditions::Range(index) => AdditionVariants::Range(match index {
-                TimeIndexWindow::Empty => TimeIndexWindowVariants::Empty(iter::empty()),
-                TimeIndexWindow::Range { timeindex, range } => TimeIndexWindowVariants::Range(
-                    timeindex
-                        .edge_ts
-                        .iter_window(range.clone())
-                        .map(|(t, e)| (*t, *e))
-                        .rev(),
-                ),
-                TimeIndexWindow::All(index) => {
-                    TimeIndexWindowVariants::All(index.edge_ts.iter().map(|(t, e)| (*t, *e)).rev())
-                }
-            }),
-            #[cfg(feature = "storage")]
-            NodeAdditions::Col(index) => AdditionVariants::Col(index.edge_history_rev()),
-        }
-    }
-}
-
-impl<'b> TimeIndexOps<'b> for NodeAdditions<'b> {
-    type IndexType = EventTime;
-    type RangeType = Self;
-
-    #[inline]
-    fn active(&self, w: Range<EventTime>) -> bool {
-        match self {
-            NodeAdditions::Mem(index) => index.active(w),
-            NodeAdditions::Range(index) => index.active(w),
-            #[cfg(feature = "storage")]
-            NodeAdditions::Col(index) => index.iter().any(|index| index.active(w.clone())),
-        }
-    }
-
-    fn range(&self, w: Range<EventTime>) -> Self {
-        match self {
-            NodeAdditions::Mem(index) => NodeAdditions::Range(index.range(w)),
-            NodeAdditions::Range(index) => NodeAdditions::Range(index.range(w)),
-            #[cfg(feature = "storage")]
-            NodeAdditions::Col(index) => NodeAdditions::Col(index.with_range(w)),
-        }
-    }
-
-    fn first(&self) -> Option<Self::IndexType> {
-        match self {
-            NodeAdditions::Mem(index) => index.first(),
-            NodeAdditions::Range(index) => index.first(),
-            #[cfg(feature = "storage")]
-            NodeAdditions::Col(index) => index.iter().flat_map(|index| index.first()).min(),
-        }
-    }
-
-    fn last(&self) -> Option<Self::IndexType> {
-        match self {
-            NodeAdditions::Mem(index) => index.last(),
-            NodeAdditions::Range(index) => index.last(),
-            #[cfg(feature = "storage")]
-            NodeAdditions::Col(index) => index.iter().flat_map(|index| index.last()).max(),
-        }
-    }
-
-    fn iter(self) -> impl Iterator<Item = Self::IndexType> + Send + Sync + 'b {
-        match self {
-            NodeAdditions::Mem(index) => AdditionVariants::Mem(index.iter()),
-            NodeAdditions::Range(index) => AdditionVariants::Range(index.iter()),
-            #[cfg(feature = "storage")]
-            NodeAdditions::Col(index) => {
-                AdditionVariants::Col(index.iter().map(|index| index.into_iter()).kmerge())
-            }
-        }
-    }
-
-    fn iter_rev(self) -> impl Iterator<Item = Self::IndexType> + Send + Sync + 'b {
-        match self {
-            NodeAdditions::Mem(index) => AdditionVariants::Mem(index.iter_rev()),
-            NodeAdditions::Range(index) => AdditionVariants::Range(index.iter_rev()),
-            #[cfg(feature = "storage")]
-            NodeAdditions::Col(index) => AdditionVariants::Col(
-                index
-                    .iter()
-                    .map(|index| index.into_iter().rev())
-                    .kmerge_by(|lt, rt| lt >= rt),
-            ),
-        }
-    }
-
-    fn len(&self) -> usize {
-        match self {
-            NodeAdditions::Mem(index) => index.len(),
-            NodeAdditions::Range(range) => range.len(),
-            #[cfg(feature = "storage")]
-            NodeAdditions::Col(col) => col.len(),
-        }
-    }
-}
diff --git a/raphtory-storage/src/graph/nodes/node_entry.rs b/raphtory-storage/src/graph/nodes/node_entry.rs
index fb94e85215..fba8bfa1c1 100644
--- a/raphtory-storage/src/graph/nodes/node_entry.rs
+++ b/raphtory-storage/src/graph/nodes/node_entry.rs
@@ -1,37 +1,25 @@
-use crate::graph::{
-    nodes::{node_ref::NodeStorageRef, node_storage_ops::NodeStorageOps},
-    variants::storage_variants3::StorageVariants3,
-};
-use raphtory_api::{
-    core::{
-        entities::{
-            edges::edge_ref::EdgeRef,
-            properties::{prop::Prop, tprop::TPropOps},
-            GidRef, LayerIds, VID,
-        },
-        Direction,
-    },
-    iter::BoxedLIter,
+use std::ops::Range;
+
+use crate::graph::nodes::{node_ref::NodeStorageRef, node_storage_ops::NodeStorageOps};
+use raphtory_api::core::{
+    entities::{edges::edge_ref::EdgeRef, properties::prop::Prop, GidRef, LayerId, LayerIds, VID},
+    Direction,
 };
-use raphtory_core::{
-    storage::{node_entry::NodePtr, NodeEntry},
-    utils::iter::GenLockedIter,
+use raphtory_core::storage::timeindex::EventTime;
+use storage::{
+    api::nodes::{self, NodeEntryOps},
+    gen_ts::LayerIter,
+    utils::Iter2,
+    NodeEntry, NodeEntryRef,
 };
-use std::borrow::Cow;
-
-#[cfg(feature = "storage")]
-use crate::disk::storage_interface::node::DiskNode;
-use crate::graph::nodes::node_additions::NodeAdditions;
 
 pub enum NodeStorageEntry<'a> {
-    Mem(NodePtr<'a>),
+    Mem(NodeEntryRef<'a>),
     Unlocked(NodeEntry<'a>),
-    #[cfg(feature = "storage")]
-    Disk(DiskNode<'a>),
 }
 
-impl<'a> From<NodePtr<'a>> for NodeStorageEntry<'a> {
-    fn from(value: NodePtr<'a>) -> Self {
+impl<'a> From<NodeEntryRef<'a>> for NodeStorageEntry<'a> {
+    fn from(value: NodeEntryRef<'a>) -> Self {
         NodeStorageEntry::Mem(value)
     }
 }
@@ -42,21 +30,12 @@ impl<'a> From<NodeEntry<'a>> for NodeStorageEntry<'a> {
     }
 }
 
-#[cfg(feature = "storage")]
-impl<'a> From<DiskNode<'a>> for NodeStorageEntry<'a> {
-    fn from(value: DiskNode<'a>) -> Self {
-        NodeStorageEntry::Disk(value)
-    }
-}
-
 impl<'a> NodeStorageEntry<'a> {
     #[inline]
     pub fn as_ref(&self) -> NodeStorageRef<'_> {
         match self {
-            NodeStorageEntry::Mem(entry) => NodeStorageRef::Mem(*entry),
-            NodeStorageEntry::Unlocked(entry) => NodeStorageRef::Mem(entry.as_ref()),
-            #[cfg(feature = "storage")]
-            NodeStorageEntry::Disk(node) => NodeStorageRef::Disk(*node),
+            NodeStorageEntry::Mem(entry) => *entry,
+            NodeStorageEntry::Unlocked(entry) => entry.as_ref(),
         }
     }
 }
@@ -68,42 +47,36 @@ impl<'a, 'b: 'a> From<&'a NodeStorageEntry<'b>> for NodeStorageRef<'a> {
 }
 
 impl<'b> NodeStorageEntry<'b> {
-    pub fn into_edges_iter(
+    pub fn into_edges_iter<'a: 'b>(
         self,
-        layers: &LayerIds,
+        layers: &'a LayerIds,
         dir: Direction,
-    ) -> impl Iterator<Item = EdgeRef> + use<'b, '_> {
+    ) -> impl Iterator<Item = EdgeRef> + Send + Sync + 'b {
         match self {
-            NodeStorageEntry::Mem(entry) => StorageVariants3::Mem(entry.edges_iter(layers, dir)),
-            NodeStorageEntry::Unlocked(entry) => {
-                StorageVariants3::Unlocked(entry.into_edges(layers, dir))
+            NodeStorageEntry::Mem(entry) => {
+                Iter2::I1(nodes::NodeRefOps::edges_iter(entry, layers, dir))
             }
-            #[cfg(feature = "storage")]
-            NodeStorageEntry::Disk(node) => StorageVariants3::Disk(node.edges_iter(layers, dir)),
+            NodeStorageEntry::Unlocked(entry) => Iter2::I2(entry.into_edges(layers, dir)),
         }
     }
 
-    pub fn metadata_ids(self) -> BoxedLIter<'b, usize> {
-        match self {
-            NodeStorageEntry::Mem(entry) => Box::new(entry.node().metadata_ids()),
-            NodeStorageEntry::Unlocked(entry) => Box::new(GenLockedIter::from(entry, |e| {
-                Box::new(e.as_ref().node().metadata_ids())
-            })),
-            #[cfg(feature = "storage")]
-            NodeStorageEntry::Disk(node) => Box::new(node.node_metadata_ids()),
-        }
-    }
-
-    pub fn temporal_prop_ids(self) -> Box<dyn Iterator<Item = usize> + 'b> {
-        match self {
-            NodeStorageEntry::Mem(entry) => Box::new(entry.temporal_prop_ids()),
-            NodeStorageEntry::Unlocked(entry) => Box::new(GenLockedIter::from(entry, |e| {
-                Box::new(e.as_ref().temporal_prop_ids())
-            })),
-            #[cfg(feature = "storage")]
-            NodeStorageEntry::Disk(node) => Box::new(node.temporal_node_prop_ids()),
-        }
-    }
+    // pub fn prop_ids(self) -> BoxedLIter<'b, usize> {
+    //     match self {
+    //         NodeStorageEntry::Mem(entry) => Box::new(entry.node().const_prop_ids()),
+    //         NodeStorageEntry::Unlocked(entry) => Box::new(GenLockedIter::from(entry, |e| {
+    //             Box::new(e.as_ref().node().const_prop_ids())
+    //         })),
+    //     }
+    // }
+
+    // pub fn temporal_prop_ids(self) -> Box<dyn Iterator<Item = usize> + 'b> {
+    //     match self {
+    //         NodeStorageEntry::Mem(entry) => Box::new(entry.temporal_prop_ids()),
+    //         NodeStorageEntry::Unlocked(entry) => Box::new(GenLockedIter::from(entry, |e| {
+    //             Box::new(e.as_ref().temporal_prop_ids())
+    //         })),
+    //     }
+    // }
 }
 
 impl<'a, 'b: 'a> NodeStorageOps<'a> for &'a NodeStorageEntry<'b> {
@@ -111,15 +84,15 @@ impl<'a, 'b: 'a> NodeStorageOps<'a> for &'a NodeStorageEntry<'b> {
         self.as_ref().degree(layers, dir)
     }
 
-    fn additions(self) -> NodeAdditions<'a> {
+    fn additions(self) -> storage::NodePropAdditions<'a> {
         self.as_ref().additions()
     }
 
-    fn tprop(self, prop_id: usize) -> impl TPropOps<'a> {
-        self.as_ref().tprop(prop_id)
-    }
-
-    fn edges_iter(self, layers: &LayerIds, dir: Direction) -> impl Iterator<Item = EdgeRef> + 'a {
+    fn edges_iter(
+        self,
+        layers: &LayerIds,
+        dir: Direction,
+    ) -> impl Iterator<Item = EdgeRef> + Send + Sync + 'a {
         self.as_ref().edges_iter(layers, dir)
     }
 
@@ -135,19 +108,48 @@ impl<'a, 'b: 'a> NodeStorageOps<'a> for &'a NodeStorageEntry<'b> {
         self.as_ref().id()
     }
 
-    fn name(self) -> Option<Cow<'a, str>> {
-        self.as_ref().name()
-    }
-
     fn find_edge(self, dst: VID, layer_ids: &LayerIds) -> Option<EdgeRef> {
         self.as_ref().find_edge(dst, layer_ids)
     }
 
-    fn prop(self, prop_id: usize) -> Option<Prop> {
-        self.as_ref().prop(prop_id)
+    fn layer_ids_iter(
+        self,
+        layer_ids: &'a LayerIds,
+    ) -> impl Iterator<Item = LayerId> + Send + Sync + 'a {
+        self.as_ref().layer_ids_iter(layer_ids)
+    }
+
+    fn temporal_prop_layer(self, layer_id: LayerId, prop_id: usize) -> storage::NodeTProps<'a> {
+        self.as_ref().temporal_prop_layer(layer_id, prop_id)
+    }
+
+    fn constant_prop_layer(self, layer_id: LayerId, prop_id: usize) -> Option<Prop> {
+        self.as_ref().constant_prop_layer(layer_id, prop_id)
     }
 
-    fn tprops(self) -> impl Iterator<Item = (usize, impl TPropOps<'a>)> {
-        self.as_ref().tprops()
+    fn temp_prop_rows_range(
+        self,
+        w: Option<Range<EventTime>>,
+    ) -> impl Iterator<Item = (EventTime, usize, Vec<(usize, Prop)>)> {
+        self.as_ref().temp_prop_rows_range(w)
+    }
+
+    fn tprop(self, prop_id: usize) -> storage::NodeTProps<'a> {
+        self.as_ref().tprop(prop_id)
+    }
+
+    fn num_layers(self) -> usize {
+        self.as_ref().num_layers()
+    }
+
+    fn node_additions<L: Into<LayerIter<'a>>>(self, layer_id: L) -> storage::NodePropAdditions<'a> {
+        self.as_ref().node_additions(layer_id)
+    }
+
+    fn node_edge_additions<L: Into<LayerIter<'a>>>(
+        self,
+        layer_id: L,
+    ) -> storage::NodeEdgeAdditions<'a> {
+        self.as_ref().node_edge_additions(layer_id)
     }
 }
diff --git a/raphtory-storage/src/graph/nodes/node_ref.rs b/raphtory-storage/src/graph/nodes/node_ref.rs
index c5f4918553..a18acdbf44 100644
--- a/raphtory-storage/src/graph/nodes/node_ref.rs
+++ b/raphtory-storage/src/graph/nodes/node_ref.rs
@@ -1,160 +1,3 @@
-use super::row::Row;
-use crate::graph::{
-    nodes::{node_additions::NodeAdditions, node_storage_ops::NodeStorageOps},
-    variants::storage_variants2::StorageVariants2,
-};
-use raphtory_api::{
-    core::{
-        entities::{
-            edges::edge_ref::EdgeRef,
-            properties::{prop::Prop, tprop::TPropOps},
-            GidRef, LayerIds, VID,
-        },
-        storage::timeindex::EventTime,
-        Direction,
-    },
-    iter::IntoDynBoxed,
-};
-use raphtory_core::storage::node_entry::NodePtr;
-use std::{borrow::Cow, ops::Range};
+use storage::NodeEntryRef;
 
-#[cfg(feature = "storage")]
-use crate::disk::storage_interface::node::DiskNode;
-
-#[derive(Copy, Clone, Debug)]
-pub enum NodeStorageRef<'a> {
-    Mem(NodePtr<'a>),
-    #[cfg(feature = "storage")]
-    Disk(DiskNode<'a>),
-}
-
-impl<'a> NodeStorageRef<'a> {
-    pub fn temp_prop_rows(self) -> impl Iterator<Item = (EventTime, Row<'a>)> + 'a {
-        match self {
-            NodeStorageRef::Mem(node_entry) => node_entry
-                .into_rows()
-                .map(|(t, row)| (t, Row::Mem(row)))
-                .into_dyn_boxed(),
-            #[cfg(feature = "storage")]
-            NodeStorageRef::Disk(disk_node) => disk_node.into_rows().into_dyn_boxed(),
-        }
-    }
-
-    pub fn temp_prop_rows_window(
-        self,
-        window: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, Row<'a>)> + 'a {
-        match self {
-            NodeStorageRef::Mem(node_entry) => node_entry
-                .into_rows_window(window)
-                .map(|(t, row)| (t, Row::Mem(row)))
-                .into_dyn_boxed(),
-            #[cfg(feature = "storage")]
-            NodeStorageRef::Disk(disk_node) => disk_node.into_rows_window(window).into_dyn_boxed(),
-        }
-    }
-
-    pub fn last_before_row(self, t: EventTime) -> Vec<(usize, Prop)> {
-        match self {
-            NodeStorageRef::Mem(node_entry) => node_entry.last_before_row(t),
-            #[cfg(feature = "storage")]
-            NodeStorageRef::Disk(disk_node) => disk_node.last_before_row(t),
-        }
-    }
-}
-
-impl<'a> From<NodePtr<'a>> for NodeStorageRef<'a> {
-    fn from(value: NodePtr<'a>) -> Self {
-        NodeStorageRef::Mem(value)
-    }
-}
-
-#[cfg(feature = "storage")]
-impl<'a> From<DiskNode<'a>> for NodeStorageRef<'a> {
-    fn from(value: DiskNode<'a>) -> Self {
-        NodeStorageRef::Disk(value)
-    }
-}
-
-macro_rules! for_all {
-    ($value:expr, $pattern:pat => $result:expr) => {
-        match $value {
-            NodeStorageRef::Mem($pattern) => $result,
-            #[cfg(feature = "storage")]
-            NodeStorageRef::Disk($pattern) => $result,
-        }
-    };
-}
-
-#[cfg(feature = "storage")]
-macro_rules! for_all_iter {
-    ($value:expr, $pattern:pat => $result:expr) => {{
-        match $value {
-            NodeStorageRef::Mem($pattern) => StorageVariants2::Mem($result),
-            NodeStorageRef::Disk($pattern) => StorageVariants2::Disk($result),
-        }
-    }};
-}
-
-#[cfg(not(feature = "storage"))]
-macro_rules! for_all_iter {
-    ($value:expr, $pattern:pat => $result:expr) => {{
-        match $value {
-            NodeStorageRef::Mem($pattern) => $result,
-        }
-    }};
-}
-
-impl<'a> NodeStorageOps<'a> for NodeStorageRef<'a> {
-    fn degree(self, layers: &LayerIds, dir: Direction) -> usize {
-        for_all!(self, node => node.degree(layers, dir))
-    }
-
-    fn additions(self) -> NodeAdditions<'a> {
-        for_all!(self, node => node.additions())
-    }
-
-    fn tprop(self, prop_id: usize) -> impl TPropOps<'a> {
-        for_all_iter!(self, node => node.tprop(prop_id))
-    }
-
-    fn edges_iter(self, layers: &LayerIds, dir: Direction) -> impl Iterator<Item = EdgeRef> + 'a {
-        for_all_iter!(self, node => node.edges_iter(layers, dir))
-    }
-
-    fn node_type_id(self) -> usize {
-        for_all!(self, node => node.node_type_id())
-    }
-
-    fn vid(self) -> VID {
-        for_all!(self, node => node.vid())
-    }
-
-    fn id(self) -> GidRef<'a> {
-        for_all!(self, node => node.id())
-    }
-
-    fn name(self) -> Option<Cow<'a, str>> {
-        for_all!(self, node => node.name())
-    }
-
-    fn find_edge(self, dst: VID, layer_ids: &LayerIds) -> Option<EdgeRef> {
-        for_all!(self, node => NodeStorageOps::find_edge(node, dst, layer_ids))
-    }
-
-    fn prop(self, prop_id: usize) -> Option<Prop> {
-        for_all!(self, node => node.prop(prop_id))
-    }
-
-    fn tprops(self) -> impl Iterator<Item = (usize, impl TPropOps<'a>)> {
-        match self {
-            NodeStorageRef::Mem(node) => {
-                StorageVariants2::Mem(node.tprops().map(|(k, v)| (k, StorageVariants2::Mem(v))))
-            }
-            #[cfg(feature = "storage")]
-            NodeStorageRef::Disk(node) => {
-                StorageVariants2::Disk(node.tprops().map(|(k, v)| (k, StorageVariants2::Disk(v))))
-            }
-        }
-    }
-}
+pub type NodeStorageRef<'a> = NodeEntryRef<'a>;
diff --git a/raphtory-storage/src/graph/nodes/node_storage_ops.rs b/raphtory-storage/src/graph/nodes/node_storage_ops.rs
index 5eff2dbb58..2019895815 100644
--- a/raphtory-storage/src/graph/nodes/node_storage_ops.rs
+++ b/raphtory-storage/src/graph/nodes/node_storage_ops.rs
@@ -1,26 +1,19 @@
-use crate::graph::nodes::node_additions::NodeAdditions;
 use raphtory_api::core::{
     entities::{
         edges::edge_ref::EdgeRef,
-        properties::{prop::Prop, tprop::TPropOps},
-        GidRef, LayerIds, VID,
+        properties::{meta::STATIC_GRAPH_LAYER_ID, prop::Prop},
+        GidRef, LayerId, LayerIds, VID,
     },
+    storage::timeindex::TimeIndexOps,
     Direction,
 };
-use raphtory_core::{entities::nodes::node_store::NodeStore, storage::node_entry::NodePtr};
-use std::borrow::Cow;
+use raphtory_core::{entities::LayerVariants, storage::timeindex::EventTime};
+use std::{borrow::Cow, ops::Range};
+use storage::{api::nodes::NodeRefOps, gen_ts::LayerIter, NodeEntryRef};
 
-pub trait NodeStorageOps<'a>: Sized {
+pub trait NodeStorageOps<'a>: Copy + Sized + Send + Sync + 'a {
     fn degree(self, layers: &LayerIds, dir: Direction) -> usize;
 
-    fn additions(self) -> NodeAdditions<'a>;
-
-    fn tprop(self, prop_id: usize) -> impl TPropOps<'a>;
-
-    fn tprops(self) -> impl Iterator<Item = (usize, impl TPropOps<'a>)>;
-
-    fn prop(self, prop_id: usize) -> Option<Prop>;
-
     fn edges_iter(
         self,
         layers: &LayerIds,
@@ -33,55 +26,194 @@ pub trait NodeStorageOps<'a>: Sized {
 
     fn id(self) -> GidRef<'a>;
 
-    fn name(self) -> Option<Cow<'a, str>>;
+    fn name(self) -> Cow<'a, str> {
+        self.id().to_str()
+    }
 
     fn find_edge(self, dst: VID, layer_ids: &LayerIds) -> Option<EdgeRef>;
-}
 
-impl<'a> NodeStorageOps<'a> for NodePtr<'a> {
-    fn degree(self, layers: &LayerIds, dir: Direction) -> usize {
-        self.node.degree(layers, dir)
+    fn layer_ids_iter(
+        self,
+        layer_ids: &'a LayerIds,
+    ) -> impl Iterator<Item = LayerId> + Send + Sync + 'a;
+
+    fn has_layers(self, layer_ids: &'a LayerIds) -> bool {
+        !self.additions().is_empty() || self.layer_ids_iter(layer_ids).next().is_some()
+    }
+
+    fn node_additions<L: Into<LayerIter<'a>>>(self, layer_id: L) -> storage::NodePropAdditions<'a>;
+
+    fn node_edge_additions<L: Into<LayerIter<'a>>>(
+        self,
+        layer_id: L,
+    ) -> storage::NodeEdgeAdditions<'a>;
+
+    fn additions(self) -> storage::NodePropAdditions<'a>;
+
+    fn temporal_prop_layer(self, layer_id: LayerId, prop_id: usize) -> storage::NodeTProps<'a>;
+
+    fn temporal_prop_iter(
+        self,
+        layer_ids: &'a LayerIds,
+        prop_id: usize,
+    ) -> impl Iterator<Item = (LayerId, storage::NodeTProps<'a>)> + 'a {
+        self.layer_ids_iter(layer_ids)
+            .map(move |id| (id, self.temporal_prop_layer(id, prop_id)))
     }
 
-    fn additions(self) -> NodeAdditions<'a> {
-        NodeAdditions::Mem(self.node.timestamps())
+    fn tprop(self, prop_id: usize) -> storage::NodeTProps<'a>;
+
+    /// Number of layers in the underlying storage for this node.
+    fn num_layers(self) -> usize;
+
+    /// Iterate over `NodeTProps` for each layer specified by `layer_ids`, always
+    /// including `STATIC_GRAPH_LAYER_ID` (the layer for nodes added without an
+    /// explicit layer name).  This mirrors the behaviour of `layer_ids_with_static`
+    /// used for node additions: unlayered nodes must be visible in every view.
+    fn tprop_iter_layers(
+        self,
+        layer_ids: &LayerIds,
+        prop_id: usize,
+    ) -> impl Iterator<Item = storage::NodeTProps<'a>> + Send + Sync + 'a {
+        let layers: Vec<LayerId> = match layer_ids {
+            // No edge layers requested → still include STATIC so unlayered nodes show their props.
+            LayerIds::None => vec![STATIC_GRAPH_LAYER_ID],
+            // All layers already includes STATIC.
+            LayerIds::All => (0..self.num_layers()).map(LayerId).collect(),
+            LayerIds::One(id) => {
+                if *id == STATIC_GRAPH_LAYER_ID {
+                    vec![*id]
+                } else {
+                    let mut v = vec![STATIC_GRAPH_LAYER_ID, *id];
+                    v.sort();
+                    v
+                }
+            }
+            LayerIds::Multiple(ids) => {
+                if ids.contains(STATIC_GRAPH_LAYER_ID) {
+                    ids.into_iter().collect()
+                } else {
+                    let mut v: Vec<LayerId> = std::iter::once(STATIC_GRAPH_LAYER_ID)
+                        .chain(ids.into_iter())
+                        .collect();
+                    v.sort();
+                    v
+                }
+            }
+        };
+        layers
+            .into_iter()
+            .map(move |id| self.temporal_prop_layer(id, prop_id))
     }
 
-    fn tprop(self, prop_id: usize) -> impl TPropOps<'a> {
-        self.t_prop(prop_id)
+    fn constant_prop_layer(self, layer_id: LayerId, prop_id: usize) -> Option<Prop>;
+
+    fn constant_prop_iter(
+        self,
+        layer_ids: &'a LayerIds,
+        prop_id: usize,
+    ) -> impl Iterator<Item = (LayerId, Prop)> + 'a {
+        self.layer_ids_iter(layer_ids)
+            .filter_map(move |id| Some((id, self.constant_prop_layer(id, prop_id)?)))
     }
 
-    fn tprops(self) -> impl Iterator<Item = (usize, impl TPropOps<'a>)> {
-        self.temporal_prop_ids()
-            .map(move |tid| (tid, self.tprop(tid)))
+    fn temp_prop_rows_range(
+        self,
+        w: Option<Range<EventTime>>,
+    ) -> impl Iterator<Item = (EventTime, usize, Vec<(usize, Prop)>)>;
+
+    fn temp_prop_rows(self) -> impl Iterator<Item = (EventTime, usize, Vec<(usize, Prop)>)> {
+        self.temp_prop_rows_range(None)
     }
+}
 
-    fn prop(self, prop_id: usize) -> Option<Prop> {
-        self.node.metadata(prop_id).cloned()
+impl<'a> NodeStorageOps<'a> for NodeEntryRef<'a> {
+    fn degree(self, layers: &LayerIds, dir: Direction) -> usize {
+        NodeRefOps::degree(self, layers, dir)
     }
 
-    fn edges_iter(self, layers: &LayerIds, dir: Direction) -> impl Iterator<Item = EdgeRef> + 'a {
-        self.node.edge_tuples(layers, dir)
+    fn edges_iter(
+        self,
+        layers: &LayerIds,
+        dir: Direction,
+    ) -> impl Iterator<Item = EdgeRef> + Send + Sync + 'a {
+        NodeRefOps::edges_iter(self, layers, dir)
     }
 
     fn node_type_id(self) -> usize {
-        self.node.node_type
+        NodeRefOps::node_type_id(&self)
     }
 
     fn vid(self) -> VID {
-        self.node.vid
+        NodeRefOps::vid(&self)
     }
 
     fn id(self) -> GidRef<'a> {
-        (&self.node.global_id).into()
+        NodeRefOps::gid(&self)
     }
 
-    fn name(self) -> Option<Cow<'a, str>> {
-        self.node.global_id.as_str().map(Cow::from)
+    fn find_edge(self, dst: VID, layer_ids: &LayerIds) -> Option<EdgeRef> {
+        NodeRefOps::find_edge(&self, dst, layer_ids)
     }
 
-    fn find_edge(self, dst: VID, layer_ids: &LayerIds) -> Option<EdgeRef> {
-        let eid = NodeStore::find_edge_eid(self.node, dst, layer_ids)?;
-        Some(EdgeRef::new_outgoing(eid, self.node.vid, dst))
+    fn layer_ids_iter(
+        self,
+        layer_ids: &'a LayerIds,
+    ) -> impl Iterator<Item = LayerId> + Send + Sync + 'a {
+        match layer_ids {
+            LayerIds::None => LayerVariants::None(std::iter::empty()),
+            LayerIds::All => LayerVariants::All(
+                (0..self.internal_num_layers())
+                    .map(LayerId)
+                    .filter(move |&l| self.has_layer_inner(l)),
+            ),
+            LayerIds::One(id) => {
+                LayerVariants::One(self.has_layer_inner(*id).then_some(*id).into_iter())
+            }
+            LayerIds::Multiple(ids) => {
+                LayerVariants::Multiple(ids.iter().filter(move |&id| self.has_layer_inner(id)))
+            }
+        }
+    }
+
+    fn node_additions<L: Into<LayerIter<'a>>>(
+        self,
+        layer_ids: L,
+    ) -> storage::NodePropAdditions<'a> {
+        NodeRefOps::node_additions(self, layer_ids)
+    }
+
+    fn node_edge_additions<L: Into<LayerIter<'a>>>(
+        self,
+        layer_id: L,
+    ) -> storage::NodeEdgeAdditions<'a> {
+        NodeRefOps::edge_additions(self, layer_id)
+    }
+
+    fn additions(self) -> storage::NodePropAdditions<'a> {
+        NodeRefOps::node_additions(self, 0)
+    }
+
+    fn tprop(self, prop_id: usize) -> storage::NodeTProps<'a> {
+        NodeRefOps::temporal_prop_layer(self, LayerId(0), prop_id)
+    }
+
+    fn num_layers(self) -> usize {
+        NodeRefOps::internal_num_layers(&self)
+    }
+
+    fn temporal_prop_layer(self, layer_id: LayerId, prop_id: usize) -> storage::NodeTProps<'a> {
+        NodeRefOps::temporal_prop_layer(self, layer_id, prop_id)
+    }
+
+    fn constant_prop_layer(self, layer_id: LayerId, prop_id: usize) -> Option<Prop> {
+        NodeRefOps::c_prop(self, layer_id, prop_id)
+    }
+
+    fn temp_prop_rows_range(
+        self,
+        w: Option<Range<EventTime>>,
+    ) -> impl Iterator<Item = (EventTime, usize, Vec<(usize, Prop)>)> {
+        NodeRefOps::temp_prop_rows(self, w)
     }
 }
diff --git a/raphtory-storage/src/graph/nodes/nodes.rs b/raphtory-storage/src/graph/nodes/nodes.rs
index d95f50da47..173edacd4b 100644
--- a/raphtory-storage/src/graph/nodes/nodes.rs
+++ b/raphtory-storage/src/graph/nodes/nodes.rs
@@ -1,38 +1,31 @@
+use std::sync::Arc;
+
 use super::node_ref::NodeStorageRef;
 use crate::graph::nodes::nodes_ref::NodesStorageEntry;
 use raphtory_api::core::entities::VID;
-use raphtory_core::storage::ReadLockedStorage;
-use std::sync::Arc;
+use storage::{Extension, ReadLockedNodes};
 
-#[cfg(feature = "storage")]
-use crate::disk::storage_interface::nodes::DiskNodesOwned;
-
-pub enum NodesStorage {
-    Mem(Arc<ReadLockedStorage>),
-    #[cfg(feature = "storage")]
-    Disk(DiskNodesOwned),
+#[repr(transparent)]
+pub struct NodesStorage {
+    storage: Arc<ReadLockedNodes<Extension>>,
 }
 
 impl NodesStorage {
+    pub fn new(storage: Arc<ReadLockedNodes<Extension>>) -> Self {
+        Self { storage }
+    }
+
     #[inline]
     pub fn as_ref(&self) -> NodesStorageEntry<'_> {
-        match self {
-            NodesStorage::Mem(storage) => NodesStorageEntry::Mem(storage),
-            #[cfg(feature = "storage")]
-            NodesStorage::Disk(storage) => NodesStorageEntry::Disk(storage.as_ref()),
-        }
+        NodesStorageEntry::Mem(self.storage.as_ref())
     }
 
     #[inline]
     pub fn node_entry(&self, vid: VID) -> NodeStorageRef<'_> {
-        match self {
-            NodesStorage::Mem(storage) => NodeStorageRef::Mem(storage.get_entry(vid)),
-            #[cfg(feature = "storage")]
-            NodesStorage::Disk(storage) => NodeStorageRef::Disk(storage.node(vid)),
-        }
+        self.storage.node_ref(vid)
     }
 
     pub fn len(&self) -> usize {
-        self.as_ref().len()
+        self.storage.len()
     }
 }
diff --git a/raphtory-storage/src/graph/nodes/nodes_ref.rs b/raphtory-storage/src/graph/nodes/nodes_ref.rs
index dfe02fbde2..f170f8dafd 100644
--- a/raphtory-storage/src/graph/nodes/nodes_ref.rs
+++ b/raphtory-storage/src/graph/nodes/nodes_ref.rs
@@ -1,18 +1,13 @@
 use super::node_ref::NodeStorageRef;
 use crate::graph::variants::storage_variants3::StorageVariants3;
 use raphtory_api::core::entities::VID;
-use raphtory_core::storage::ReadLockedStorage;
 use rayon::iter::ParallelIterator;
-
-#[cfg(feature = "storage")]
-use crate::disk::storage_interface::nodes_ref::DiskNodesRef;
+use storage::{Extension, ReadLockedNodes};
 
 #[derive(Debug)]
 pub enum NodesStorageEntry<'a> {
-    Mem(&'a ReadLockedStorage),
-    Unlocked(ReadLockedStorage),
-    #[cfg(feature = "storage")]
-    Disk(DiskNodesRef<'a>),
+    Mem(&'a ReadLockedNodes<Extension>),
+    Unlocked(ReadLockedNodes<Extension>),
 }
 
 macro_rules! for_all_variants {
@@ -20,8 +15,6 @@ macro_rules! for_all_variants {
         match $value {
             NodesStorageEntry::Mem($pattern) => StorageVariants3::Mem($result),
             NodesStorageEntry::Unlocked($pattern) => StorageVariants3::Unlocked($result),
-            #[cfg(feature = "storage")]
-            NodesStorageEntry::Disk($pattern) => StorageVariants3::Disk($result),
         }
     };
 }
@@ -29,10 +22,8 @@ macro_rules! for_all_variants {
 impl<'a> NodesStorageEntry<'a> {
     pub fn node(&self, vid: VID) -> NodeStorageRef<'_> {
         match self {
-            NodesStorageEntry::Mem(store) => NodeStorageRef::Mem(store.get_entry(vid)),
-            NodesStorageEntry::Unlocked(store) => NodeStorageRef::Mem(store.get_entry(vid)),
-            #[cfg(feature = "storage")]
-            NodesStorageEntry::Disk(store) => NodeStorageRef::Disk(store.node(vid)),
+            NodesStorageEntry::Mem(store) => store.node_ref(vid),
+            NodesStorageEntry::Unlocked(store) => store.node_ref(vid),
         }
     }
 
@@ -40,16 +31,25 @@ impl<'a> NodesStorageEntry<'a> {
         match self {
             NodesStorageEntry::Mem(store) => store.len(),
             NodesStorageEntry::Unlocked(store) => store.len(),
-            #[cfg(feature = "storage")]
-            NodesStorageEntry::Disk(store) => store.len(),
         }
     }
 
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
     pub fn par_iter(&self) -> impl ParallelIterator<Item = NodeStorageRef<'_>> {
-        for_all_variants!(self, nodes => nodes.par_iter().map(|n| n.into()))
+        for_all_variants!(self, nodes => nodes.par_iter())
     }
 
     pub fn iter(&self) -> impl Iterator<Item = NodeStorageRef<'_>> {
-        for_all_variants!(self, nodes => nodes.iter().map(|n| n.into()))
+        for_all_variants!(self, nodes => nodes.iter())
+    }
+
+    /// Returns a parallel iterator over nodes row groups
+    /// the (usize) part is the row group not the segment
+    pub fn row_groups_par_iter(
+        &self,
+    ) -> impl ParallelIterator<Item = (usize, impl Iterator<Item = VID> + '_)> {
+        for_all_variants!(self, nodes => nodes.row_groups_par_iter())
     }
 }
diff --git a/raphtory-storage/src/graph/nodes/row.rs b/raphtory-storage/src/graph/nodes/row.rs
deleted file mode 100644
index b10dfb2062..0000000000
--- a/raphtory-storage/src/graph/nodes/row.rs
+++ /dev/null
@@ -1,90 +0,0 @@
-use raphtory_api::core::entities::properties::prop::Prop;
-use raphtory_core::storage::node_entry::MemRow;
-
-#[cfg(feature = "storage")]
-use {
-    pometry_storage::{
-        graph::TemporalGraph, properties::TemporalProps, timestamps::TimeStamps, tprops::DiskTProp,
-        tprops::PropCol,
-    },
-    raphtory_api::core::{entities::VID, storage::timeindex::EventTime},
-};
-
-#[derive(Debug, Copy, Clone)]
-pub enum Row<'a> {
-    Mem(MemRow<'a>),
-    #[cfg(feature = "storage")]
-    Disk(DiskRow<'a>),
-}
-
-impl<'a> IntoIterator for Row<'a> {
-    type Item = (usize, Option<Prop>);
-
-    type IntoIter = Box<dyn Iterator<Item = Self::Item> + 'a>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        match self {
-            Row::Mem(mem_row) => mem_row.into_iter(),
-            #[cfg(feature = "storage")]
-            Row::Disk(disk_row) => disk_row.into_iter(),
-        }
-    }
-}
-
-#[cfg(feature = "storage")]
-#[derive(Debug, Copy, Clone)]
-pub struct DiskRow<'a> {
-    graph: &'a TemporalGraph,
-    ts: TimeStamps<'a, EventTime>,
-    layer: usize,
-    row: usize,
-}
-
-#[cfg(feature = "storage")]
-impl<'a> DiskRow<'a> {
-    pub fn new(
-        graph: &'a TemporalGraph,
-        ts: TimeStamps<'a, EventTime>,
-        row: usize,
-        layer: usize,
-    ) -> Self {
-        Self {
-            graph,
-            ts,
-            row,
-            layer,
-        }
-    }
-
-    pub fn temporal_props(&'a self) -> &'a TemporalProps<VID> {
-        &self.graph.node_properties().temporal_props()[self.layer]
-    }
-}
-
-#[cfg(feature = "storage")]
-impl<'a> IntoIterator for DiskRow<'a> {
-    type Item = (usize, Option<Prop>);
-
-    type IntoIter = Box<dyn Iterator<Item = Self::Item> + 'a>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        let props = self.temporal_props();
-        let iter = (0..props.prop_dtypes().len()).filter_map(move |prop_id| {
-            let global_prop = self
-                .graph
-                .prop_mapping()
-                .globalise_node_prop_id(self.layer, prop_id)?;
-            let props = self.temporal_props();
-            Some((
-                global_prop,
-                get(&props.prop_for_ts::<EventTime>(self.ts, prop_id), self.row),
-            ))
-        });
-        Box::new(iter)
-    }
-}
-
-#[cfg(feature = "storage")]
-fn get<'a>(disk_col: &DiskTProp<'a, EventTime>, row: usize) -> Option<Prop> {
-    disk_col.get_prop_row(row)
-}
diff --git a/raphtory-storage/src/graph/variants/storage_variants2.rs b/raphtory-storage/src/graph/variants/storage_variants2.rs
index 16fc5ae514..949a444a26 100644
--- a/raphtory-storage/src/graph/variants/storage_variants2.rs
+++ b/raphtory-storage/src/graph/variants/storage_variants2.rs
@@ -20,20 +20,10 @@ use std::ops::Range;
     IndexedParallelIterator,
     ParallelExtend,
 )]
-pub enum StorageVariants2<Mem, #[cfg(feature = "storage")] Disk> {
+pub enum StorageVariants2<Mem> {
     Mem(Mem),
-    #[cfg(feature = "storage")]
-    Disk(Disk),
 }
 
-#[cfg(feature = "storage")]
-macro_rules! SelfType {
-    ($Mem:ident, $Disk:ident) => {
-        StorageVariants2<$Mem, $Disk>
-    };
-}
-
-#[cfg(not(feature = "storage"))]
 macro_rules! SelfType {
     ($Mem:ident, $Disk:ident) => {
         StorageVariants2<$Mem>
@@ -44,23 +34,10 @@ macro_rules! for_all {
     ($value:expr, $pattern:pat => $result:expr) => {
         match $value {
             StorageVariants2::Mem($pattern) => $result,
-            #[cfg(feature = "storage")]
-            StorageVariants2::Disk($pattern) => $result,
-        }
-    };
-}
-
-#[cfg(feature = "storage")]
-macro_rules! for_all_iter {
-    ($value:expr, $pattern:pat => $result:expr) => {
-        match $value {
-            StorageVariants2::Mem($pattern) => StorageVariants2::Mem($result),
-            StorageVariants2::Disk($pattern) => StorageVariants2::Disk($result),
         }
     };
 }
 
-#[cfg(not(feature = "storage"))]
 macro_rules! for_all_iter {
     ($value:expr, $pattern:pat => $result:expr) => {
         match $value {
@@ -69,22 +46,23 @@ macro_rules! for_all_iter {
     };
 }
 
-impl<'a, Mem: TPropOps<'a> + 'a, #[cfg(feature = "storage")] Disk: TPropOps<'a> + 'a> TPropOps<'a>
-    for SelfType!(Mem, Disk)
-{
+impl<'a, Mem: TPropOps<'a> + 'a> TPropOps<'a> for SelfType!(Mem, Disk) {
     fn last_before(&self, t: EventTime) -> Option<(EventTime, Prop)> {
         for_all!(self, props => props.last_before(t))
     }
 
-    fn iter(self) -> impl DoubleEndedIterator<Item = (EventTime, Prop)> + Send + Sync + 'a {
-        for_all_iter!(self, props => props.iter())
+    fn iter_inner(
+        self,
+        range: Option<Range<EventTime>>,
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'a {
+        for_all_iter!(self, props => props.iter_inner(range))
     }
 
-    fn iter_window(
+    fn iter_inner_rev(
         self,
-        r: Range<EventTime>,
-    ) -> impl DoubleEndedIterator<Item = (EventTime, Prop)> + Send + Sync + 'a {
-        for_all_iter!(self, props => props.iter_window(r))
+        range: Option<Range<EventTime>>,
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'a {
+        for_all_iter!(self, props => props.iter_inner_rev(range))
     }
 
     fn at(&self, ti: &EventTime) -> Option<Prop> {
@@ -92,20 +70,10 @@ impl<'a, Mem: TPropOps<'a> + 'a, #[cfg(feature = "storage")] Disk: TPropOps<'a>
     }
 }
 
-impl<
-        'a,
-        Mem: TimeIndexOps<'a>,
-        #[cfg(feature = "storage")] Disk: TimeIndexOps<'a, IndexType = Mem::IndexType>,
-    > TimeIndexOps<'a> for SelfType!(Mem, Disk)
-{
+impl<'a, Mem: TimeIndexOps<'a>> TimeIndexOps<'a> for SelfType!(Mem, Disk) {
     type IndexType = Mem::IndexType;
-
-    #[cfg(not(feature = "storage"))]
     type RangeType = Mem::RangeType;
 
-    #[cfg(feature = "storage")]
-    type RangeType = StorageVariants2<Mem::RangeType, Disk::RangeType>;
-
     fn active(&self, w: Range<Self::IndexType>) -> bool {
         for_all!(self, props => props.active(w))
     }
diff --git a/raphtory-storage/src/graph/variants/storage_variants3.rs b/raphtory-storage/src/graph/variants/storage_variants3.rs
index 2199e8794f..f49a3e4224 100644
--- a/raphtory-storage/src/graph/variants/storage_variants3.rs
+++ b/raphtory-storage/src/graph/variants/storage_variants3.rs
@@ -19,21 +19,11 @@ use std::ops::Range;
     ParallelIterator,
     IndexedParallelIterator,
 )]
-pub enum StorageVariants3<Mem, Unlocked, #[cfg(feature = "storage")] Disk> {
+pub enum StorageVariants3<Mem, Unlocked> {
     Mem(Mem),
     Unlocked(Unlocked),
-    #[cfg(feature = "storage")]
-    Disk(Disk),
 }
 
-#[cfg(feature = "storage")]
-macro_rules! SelfType {
-    ($Mem:ident, $Unlocked:ident, $Disk:ident) => {
-        StorageVariants3<$Mem, $Unlocked, $Disk>
-    };
-}
-
-#[cfg(not(feature = "storage"))]
 macro_rules! SelfType {
     ($Mem:ident, $Unlocked:ident, $Disk:ident) => {
         StorageVariants3<$Mem, $Unlocked>
@@ -45,8 +35,6 @@ macro_rules! for_all {
         match $value {
             StorageVariants3::Mem($pattern) => $result,
             StorageVariants3::Unlocked($pattern) => $result,
-            #[cfg(feature = "storage")]
-            StorageVariants3::Disk($pattern) => $result,
         }
     };
 }
@@ -56,32 +44,29 @@ macro_rules! for_all_iter {
         match $value {
             StorageVariants3::Mem($pattern) => StorageVariants3::Mem($result),
             StorageVariants3::Unlocked($pattern) => StorageVariants3::Unlocked($result),
-            #[cfg(feature = "storage")]
-            StorageVariants3::Disk($pattern) => StorageVariants3::Disk($result),
         }
     };
 }
 
-impl<
-        'a,
-        Mem: TPropOps<'a> + 'a,
-        Unlocked: TPropOps<'a> + 'a,
-        #[cfg(feature = "storage")] Disk: TPropOps<'a> + 'a,
-    > TPropOps<'a> for SelfType!(Mem, Unlocked, Disk)
+impl<'a, Mem: TPropOps<'a> + 'a, Unlocked: TPropOps<'a> + 'a> TPropOps<'a>
+    for SelfType!(Mem, Unlocked, Disk)
 {
     fn last_before(&self, t: EventTime) -> Option<(EventTime, Prop)> {
         for_all!(self, props => props.last_before(t))
     }
 
-    fn iter(self) -> impl DoubleEndedIterator<Item = (EventTime, Prop)> + Send + Sync + 'a {
-        for_all_iter!(self, props => props.iter())
+    fn iter_inner(
+        self,
+        range: Option<Range<EventTime>>,
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'a {
+        for_all_iter!(self, props => props.iter_inner(range))
     }
 
-    fn iter_window(
+    fn iter_inner_rev(
         self,
-        r: Range<EventTime>,
-    ) -> impl DoubleEndedIterator<Item = (EventTime, Prop)> + Send + Sync + 'a {
-        for_all_iter!(self, props => props.iter_window(r))
+        range: Option<Range<EventTime>>,
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'a {
+        for_all_iter!(self, props => props.iter_inner_rev(range))
     }
 
     fn at(&self, ti: &EventTime) -> Option<Prop> {
diff --git a/raphtory-storage/src/layer_ops.rs b/raphtory-storage/src/layer_ops.rs
index 6d190a58b7..8780f053ff 100644
--- a/raphtory-storage/src/layer_ops.rs
+++ b/raphtory-storage/src/layer_ops.rs
@@ -19,8 +19,6 @@ pub trait InternalLayerOps: CoreGraphOps {
             GraphStorage::Mem(LockedGraph { graph, .. }) | GraphStorage::Unlocked(graph) => {
                 graph.layer_ids(key)
             }
-            #[cfg(feature = "storage")]
-            GraphStorage::Disk(graph) => graph.layer_ids_from_names(key),
         }?;
         Ok(layer_ids.intersect(self.layer_ids()))
     }
@@ -31,8 +29,6 @@ pub trait InternalLayerOps: CoreGraphOps {
             GraphStorage::Unlocked(graph) | GraphStorage::Mem(LockedGraph { graph, .. }) => {
                 graph.valid_layer_ids(key)
             }
-            #[cfg(feature = "storage")]
-            GraphStorage::Disk(graph) => graph.valid_layer_ids_from_names(key),
         };
         layer_ids.intersect(self.layer_ids())
     }
diff --git a/raphtory-storage/src/lib.rs b/raphtory-storage/src/lib.rs
index 98b6be3a3b..5e9308d61d 100644
--- a/raphtory-storage/src/lib.rs
+++ b/raphtory-storage/src/lib.rs
@@ -1,6 +1,6 @@
 pub mod core_ops;
-#[cfg(feature = "storage")]
-pub mod disk;
+pub mod durability_ops;
 pub mod graph;
 pub mod layer_ops;
 pub mod mutation;
+pub mod recovery_ops;
diff --git a/raphtory-storage/src/mutation/addition_ops.rs b/raphtory-storage/src/mutation/addition_ops.rs
index d157bbbaae..8f7c9bcc20 100644
--- a/raphtory-storage/src/mutation/addition_ops.rs
+++ b/raphtory-storage/src/mutation/addition_ops.rs
@@ -1,153 +1,166 @@
 use crate::{
-    graph::{graph::GraphStorage, locked::WriteLockedGraph},
-    mutation::MutationError,
+    graph::graph::GraphStorage,
+    mutation::{
+        addition_ops_ext::{AtomicAddEdge, AtomicAddNode, UnlockedSession},
+        MutationError, NodeWriterT,
+    },
 };
+use db4_graph::WriteLockedGraph;
 use raphtory_api::{
     core::{
         entities::{
-            properties::prop::{Prop, PropType},
-            GidRef, EID, VID,
+            properties::{
+                meta::Meta,
+                prop::{Prop, PropType},
+            },
+            GidRef, LayerId, EID, VID,
         },
         storage::{dict_mapper::MaybeNew, timeindex::EventTime},
     },
     inherit::Base,
 };
-use raphtory_core::{
-    entities::{graph::tgraph::TemporalGraph, nodes::node_ref::NodeRef},
-    storage::{raw_edges::WriteLockedEdges, WriteLockedNodes},
-};
-use std::sync::atomic::Ordering;
+use raphtory_core::entities::nodes::node_ref::NodeRef;
+use storage::{wal::LSN, Extension};
 
 pub trait InternalAdditionOps {
     type Error: From<MutationError>;
-    fn write_lock(&self) -> Result<WriteLockedGraph<'_>, Self::Error>;
-    fn write_lock_nodes(&self) -> Result<WriteLockedNodes<'_>, Self::Error>;
-    fn write_lock_edges(&self) -> Result<WriteLockedEdges<'_>, Self::Error>;
-    /// get the sequence id for the next event
-    fn next_event_id(&self) -> Result<usize, Self::Error>;
-    fn reserve_event_ids(&self, num_ids: usize) -> Result<usize, Self::Error>;
+    type WS<'a>: SessionAdditionOps<Error = Self::Error>
+    where
+        Self: 'a;
+
+    type AtomicAddEdge<'a>: EdgeWriteLock
+    where
+        Self: 'a;
+
+    fn write_lock(&self) -> Result<WriteLockedGraph<'_, Extension>, Self::Error>;
+
     /// map layer name to id and allocate a new layer if needed
-    fn resolve_layer(&self, layer: Option<&str>) -> Result<MaybeNew<usize>, Self::Error>;
-    /// map external node id to internal id, allocating a new empty node if needed
+    fn resolve_layer(&self, layer: Option<&str>) -> Result<MaybeNew<LayerId>, Self::Error>;
+
+    /// Map external node id to internal id, reserving space for a new empty node if needed.
     fn resolve_node(&self, id: NodeRef) -> Result<MaybeNew<VID>, Self::Error>;
-    fn set_node(&self, gid: GidRef, vid: VID) -> Result<(), Self::Error>;
-    /// resolve a node and corresponding type, outer MaybeNew tracks whether the type assignment is new for the node even if both node and type already existed.
-    fn resolve_node_and_type(
+
+    /// Resolve a node and corresponding type, outer MaybeNew tracks whether the type
+    /// assignment is new for the node even if both node and type already existed.
+    /// updates the storage atomically to set the node type
+    fn resolve_and_update_node_and_type(
         &self,
         id: NodeRef,
-        node_type: &str,
+        node_type: Option<&str>,
     ) -> Result<MaybeNew<(MaybeNew<VID>, MaybeNew<usize>)>, Self::Error>;
-    /// map property key to internal id, allocating new property if needed
-    fn resolve_graph_property(
+
+    /// resolve node and type without modifying the storage (use in bulk loaders only)
+    fn resolve_node_and_type(
         &self,
-        prop: &str,
-        dtype: PropType,
-        is_static: bool,
-    ) -> Result<MaybeNew<usize>, Self::Error>;
-    /// map property key to internal id, allocating new property if needed and checking property type.
-    /// returns `None` if the type does not match
-    fn resolve_node_property(
+        id: NodeRef,
+        node_type: Option<&str>,
+    ) -> Result<(VID, usize), Self::Error>;
+
+    /// SAFETY this function assumes it is called from behind a sharded structure that does not allow the same id to be resolved at the same time by more than 1 thread
+    unsafe fn bulk_load_resolve_node(&self, id: GidRef<'_>) -> Result<VID, Self::Error>;
+
+    /// validate the GidRef is the correct type
+    fn validate_gids<'a>(
         &self,
-        prop: &str,
-        dtype: PropType,
-        is_static: bool,
-    ) -> Result<MaybeNew<usize>, Self::Error>;
-    fn resolve_edge_property(
+        gids: impl IntoIterator<Item = GidRef<'a>>,
+    ) -> Result<(), Self::Error>;
+
+    fn write_session(&self) -> Result<Self::WS<'_>, Self::Error>;
+
+    fn atomic_add_edge(
         &self,
-        prop: &str,
-        dtype: PropType,
-        is_static: bool,
-    ) -> Result<MaybeNew<usize>, Self::Error>;
-    /// add node update
+        src: NodeRef,
+        dst: NodeRef,
+        e_id: Option<EID>,
+    ) -> Result<Self::AtomicAddEdge<'_>, Self::Error>;
+
+    /// Get or create writer for a node
+    fn atomic_add_node(&self, node: NodeRef) -> Result<AtomicAddNode<'_>, Self::Error>;
+
     fn internal_add_node(
         &self,
         t: EventTime,
         v: VID,
-        props: &[(usize, Prop)],
-    ) -> Result<(), Self::Error>;
-    /// add edge update
-    fn internal_add_edge(
+        props: Vec<(usize, Prop)>,
+        layer_id: LayerId,
+    ) -> Result<NodeWriterT<'_>, Self::Error>;
+
+    fn validate_props<PN: AsRef<str>>(
         &self,
-        t: EventTime,
-        src: VID,
-        dst: VID,
-        props: &[(usize, Prop)],
-        layer: usize,
-    ) -> Result<MaybeNew<EID>, Self::Error>;
-    /// add update for an existing edge
-    fn internal_add_edge_update(
+        is_static: bool,
+        meta: &Meta,
+        prop: impl Iterator<Item = (PN, Prop)>,
+    ) -> Result<Vec<(usize, Prop)>, Self::Error>;
+
+    /// Validates props and returns them with their creation status (new vs existing)
+    fn validate_props_with_status<PN: AsRef<str>>(
         &self,
+        is_static: bool,
+        meta: &Meta,
+        props: impl Iterator<Item = (PN, Prop)>,
+    ) -> Result<Vec<MaybeNew<(PN, usize, Prop)>>, Self::Error>;
+}
+
+pub trait EdgeWriteLock: Send + Sync {
+    /// add edge update
+    fn internal_add_update(
+        &mut self,
         t: EventTime,
-        edge: EID,
-        props: &[(usize, Prop)],
-        layer: usize,
-    ) -> Result<(), Self::Error>;
+        layer: LayerId,
+        props: impl IntoIterator<Item = (usize, Prop)>,
+    );
+
+    fn internal_delete_edge(&mut self, t: EventTime, layer: LayerId);
+
+    fn set_lsn(&mut self, lsn: LSN);
+
+    fn src(&self) -> MaybeNew<VID>;
+
+    fn dst(&self) -> MaybeNew<VID>;
+
+    fn eid(&self) -> MaybeNew<EID>;
 }
 
-impl InternalAdditionOps for TemporalGraph {
-    type Error = MutationError;
+pub trait NodeWriteLock: Send + Sync {
+    fn internal_add_update(
+        &mut self,
+        t: EventTime,
+        layer: LayerId,
+        props: impl IntoIterator<Item = (usize, Prop)>,
+    );
 
-    fn write_lock(&self) -> Result<WriteLockedGraph<'_>, Self::Error> {
-        Ok(WriteLockedGraph::new(self))
-    }
+    fn can_set_type(&self) -> bool;
 
-    fn write_lock_nodes(&self) -> Result<WriteLockedNodes<'_>, Self::Error> {
-        Ok(self.storage.nodes.write_lock())
-    }
+    fn get_type(&self) -> usize;
 
-    fn write_lock_edges(&self) -> Result<WriteLockedEdges<'_>, Self::Error> {
-        Ok(self.storage.edges.write_lock())
-    }
+    fn set_type(&mut self, node_type: usize);
 
-    /// get the sequence id for the next event
-    fn next_event_id(&self) -> Result<usize, Self::Error> {
-        Ok(self.event_counter.fetch_add(1, Ordering::Relaxed))
-    }
+    fn set_lsn(&mut self, lsn: LSN);
 
-    fn reserve_event_ids(&self, num_ids: usize) -> Result<usize, Self::Error> {
-        Ok(self.event_counter.fetch_add(num_ids, Ordering::Relaxed))
-    }
+    fn node(&self) -> MaybeNew<VID>;
+}
 
-    /// map layer name to id and allocate a new layer if needed
-    fn resolve_layer(&self, layer: Option<&str>) -> Result<MaybeNew<usize>, Self::Error> {
-        let id = self
-            .resolve_layer_inner(layer)
-            .map_err(MutationError::from)?;
-        Ok(id)
-    }
+pub trait SessionAdditionOps: Send + Sync {
+    type Error: From<MutationError>;
 
-    /// map external node id to internal id, allocating a new empty node if needed
-    fn resolve_node(&self, id: NodeRef) -> Result<MaybeNew<VID>, Self::Error> {
-        Ok(self.resolve_node_inner(id)?)
-    }
+    /// Reads the current event id.
+    fn read_event_id(&self) -> Result<usize, Self::Error>;
 
-    fn set_node(&self, gid: GidRef, vid: VID) -> Result<(), Self::Error> {
-        Ok(self.logical_to_physical.set(gid, vid)?)
-    }
+    /// Sets the event_id to the provided event_id.
+    fn set_event_id(&self, event_id: usize) -> Result<(), Self::Error>;
 
-    /// resolve a node and corresponding type, outer MaybeNew tracks whether the type assignment is new for the node even if both node and type already existed.
-    fn resolve_node_and_type(
-        &self,
-        id: NodeRef,
-        node_type: &str,
-    ) -> Result<MaybeNew<(MaybeNew<VID>, MaybeNew<usize>)>, Self::Error> {
-        let vid = self.resolve_node(id)?;
-        let mut entry = self.storage.get_node_mut(vid.inner());
-        let mut entry_ref = entry.to_mut();
-        let node_store = entry_ref.node_store_mut();
-        if node_store.node_type == 0 {
-            let node_type_id = self.node_meta.get_or_create_node_type_id(node_type);
-            node_store.update_node_type(node_type_id.inner());
-            Ok(MaybeNew::New((vid, node_type_id)))
-        } else {
-            let node_type_id = self
-                .node_meta
-                .get_node_type_id(node_type)
-                .filter(|&node_type| node_type == node_store.node_type)
-                .ok_or(MutationError::NodeTypeError)?;
-            Ok(MaybeNew::Existing((vid, MaybeNew::Existing(node_type_id))))
-        }
-    }
+    /// get the sequence id for the next event
+    fn next_event_id(&self) -> Result<usize, Self::Error>;
+
+    /// Reserve a consecutive block of event_ids with length num_ids.
+    /// Returns the starting event_id of the reserved block.
+    fn reserve_event_ids(&self, num_ids: usize) -> Result<usize, Self::Error>;
+
+    /// Sets the event_id to the maximum of the current event_id and the provided event_id.
+    /// Returns the old value before the update.
+    fn set_max_event_id(&self, event_id: usize) -> Result<usize, Self::Error>;
+
+    fn set_node(&self, gid: GidRef, vid: VID) -> Result<(), Self::Error>;
 
     /// map property key to internal id, allocating new property if needed
     fn resolve_graph_property(
@@ -155,9 +168,7 @@ impl InternalAdditionOps for TemporalGraph {
         prop: &str,
         dtype: PropType,
         is_static: bool,
-    ) -> Result<MaybeNew<usize>, Self::Error> {
-        Ok(self.graph_meta.resolve_property(prop, dtype, is_static)?)
-    }
+    ) -> Result<MaybeNew<usize>, Self::Error>;
 
     /// map property key to internal id, allocating new property if needed and checking property type.
     /// returns `None` if the type does not match
@@ -166,115 +177,27 @@ impl InternalAdditionOps for TemporalGraph {
         prop: &str,
         dtype: PropType,
         is_static: bool,
-    ) -> Result<MaybeNew<usize>, Self::Error> {
-        Ok(self.node_meta.resolve_prop_id(prop, dtype, is_static)?)
-    }
+    ) -> Result<MaybeNew<usize>, Self::Error>;
 
     fn resolve_edge_property(
         &self,
         prop: &str,
         dtype: PropType,
         is_static: bool,
-    ) -> Result<MaybeNew<usize>, Self::Error> {
-        Ok(self.edge_meta.resolve_prop_id(prop, dtype, is_static)?)
-    }
-
-    /// add node update
-    fn internal_add_node(
-        &self,
-        t: EventTime,
-        v: VID,
-        props: &[(usize, Prop)],
-    ) -> Result<(), Self::Error> {
-        self.update_time(t);
-        let mut entry = self.storage.get_node_mut(v);
-        let mut node = entry.to_mut();
-        let prop_i = node
-            .t_props_log_mut()
-            .push(props.iter().map(|(prop_id, prop)| {
-                let prop = self.process_prop_value(prop);
-                (*prop_id, prop)
-            }))
-            .map_err(MutationError::from)?;
-        node.node_store_mut().update_t_prop_time(t, prop_i);
-        Ok(())
-    }
-
-    /// add edge update
-    fn internal_add_edge(
-        &self,
-        t: EventTime,
-        src: VID,
-        dst: VID,
-        props: &[(usize, Prop)],
-        layer: usize,
-    ) -> Result<MaybeNew<EID>, Self::Error> {
-        let edge = self.link_nodes(src, dst, t, layer, false);
-        edge.try_map(|mut edge| {
-            let eid = edge.eid();
-            let mut edge = edge.as_mut();
-            edge.additions_mut(layer).insert(t);
-            if !props.is_empty() {
-                let edge_layer = edge.layer_mut(layer);
-                for (prop_id, prop) in props {
-                    let prop = self.process_prop_value(prop);
-                    edge_layer
-                        .add_prop(t, *prop_id, prop)
-                        .map_err(MutationError::from)?;
-                }
-            }
-            Ok(eid)
-        })
-    }
-
-    /// add update for an existing edge
-    fn internal_add_edge_update(
-        &self,
-        t: EventTime,
-        edge: EID,
-        props: &[(usize, Prop)],
-        layer: usize,
-    ) -> Result<(), Self::Error> {
-        let mut edge = self.link_edge(edge, t, layer, false);
-        let mut edge = edge.as_mut();
-        edge.additions_mut(layer).insert(t);
-        if !props.is_empty() {
-            let edge_layer = edge.layer_mut(layer);
-            for (prop_id, prop) in props {
-                let prop = self.process_prop_value(prop);
-                edge_layer
-                    .add_prop(t, *prop_id, prop)
-                    .map_err(MutationError::from)?
-            }
-        }
-        Ok(())
-    }
+    ) -> Result<MaybeNew<usize>, Self::Error>;
 }
 
 impl InternalAdditionOps for GraphStorage {
     type Error = MutationError;
+    type WS<'b> = UnlockedSession<'b>;
 
-    fn write_lock(&self) -> Result<WriteLockedGraph<'_>, Self::Error> {
-        self.mutable()?.write_lock()
-    }
-
-    fn write_lock_nodes(&self) -> Result<WriteLockedNodes<'_>, Self::Error> {
-        self.mutable()?.write_lock_nodes()
-    }
-
-    fn write_lock_edges(&self) -> Result<WriteLockedEdges<'_>, Self::Error> {
-        self.mutable()?.write_lock_edges()
-    }
+    type AtomicAddEdge<'a> = AtomicAddEdge<'a, Extension>;
 
-    fn next_event_id(&self) -> Result<usize, Self::Error> {
-        self.mutable()?.next_event_id()
-    }
-
-    fn reserve_event_ids(&self, num_ids: usize) -> Result<usize, Self::Error> {
-        self.mutable()?.reserve_event_ids(num_ids)
+    fn write_lock(&self) -> Result<WriteLockedGraph<'_, Extension>, Self::Error> {
+        self.mutable()?.write_lock()
     }
 
-    fn resolve_layer(&self, layer: Option<&str>) -> Result<MaybeNew<usize>, Self::Error> {
+    fn resolve_layer(&self, layer: Option<&str>) -> Result<MaybeNew<LayerId>, Self::Error> {
         self.mutable()?.resolve_layer(layer)
     }
 
@@ -282,77 +205,86 @@ impl InternalAdditionOps for GraphStorage {
         self.mutable()?.resolve_node(id)
     }
 
-    fn set_node(&self, gid: GidRef, vid: VID) -> Result<(), Self::Error> {
-        self.mutable()?.set_node(gid, vid)
-    }
-
-    fn resolve_node_and_type(
+    fn resolve_and_update_node_and_type(
         &self,
         id: NodeRef,
-        node_type: &str,
+        node_type: Option<&str>,
     ) -> Result<MaybeNew<(MaybeNew<VID>, MaybeNew<usize>)>, Self::Error> {
-        self.mutable()?.resolve_node_and_type(id, node_type)
+        Ok(self
+            .mutable()?
+            .resolve_and_update_node_and_type(id, node_type)?)
     }
 
-    fn resolve_graph_property(
+    fn write_session(&self) -> Result<Self::WS<'_>, Self::Error> {
+        self.mutable()?.write_session()
+    }
+
+    fn atomic_add_edge(
         &self,
-        prop: &str,
-        dtype: PropType,
-        is_static: bool,
-    ) -> Result<MaybeNew<usize>, Self::Error> {
-        self.mutable()?
-            .resolve_graph_property(prop, dtype, is_static)
+        src: NodeRef,
+        dst: NodeRef,
+        e_id: Option<EID>,
+    ) -> Result<Self::AtomicAddEdge<'_>, Self::Error> {
+        self.mutable()?.atomic_add_edge(src, dst, e_id)
     }
 
-    fn resolve_node_property(
+    fn internal_add_node(
+        &self,
+        t: EventTime,
+        v: VID,
+        props: Vec<(usize, Prop)>,
+        layer_id: LayerId,
+    ) -> Result<NodeWriterT<'_>, Self::Error> {
+        self.mutable()?.internal_add_node(t, v, props, layer_id)
+    }
+
+    fn validate_props<PN: AsRef<str>>(
         &self,
-        prop: &str,
-        dtype: PropType,
         is_static: bool,
-    ) -> Result<MaybeNew<usize>, Self::Error> {
+        meta: &Meta,
+        prop: impl Iterator<Item = (PN, Prop)>,
+    ) -> Result<Vec<(usize, Prop)>, Self::Error> {
         self.mutable()?
-            .resolve_node_property(prop, dtype, is_static)
+            .validate_props(is_static, meta, prop)
+            .map_err(MutationError::from)
     }
 
-    fn resolve_edge_property(
+    fn validate_props_with_status<PN: AsRef<str>>(
         &self,
-        prop: &str,
-        dtype: PropType,
         is_static: bool,
-    ) -> Result<MaybeNew<usize>, Self::Error> {
+        meta: &Meta,
+        props: impl Iterator<Item = (PN, Prop)>,
+    ) -> Result<Vec<MaybeNew<(PN, usize, Prop)>>, Self::Error> {
         self.mutable()?
-            .resolve_edge_property(prop, dtype, is_static)
+            .validate_props_with_status(is_static, meta, props)
+            .map_err(MutationError::from)
     }
 
-    fn internal_add_node(
+    fn validate_gids<'a>(
         &self,
-        t: EventTime,
-        v: VID,
-        props: &[(usize, Prop)],
+        gids: impl IntoIterator<Item = GidRef<'a>>,
     ) -> Result<(), Self::Error> {
-        self.mutable()?.internal_add_node(t, v, props)
+        Ok(self.mutable()?.validate_gids(gids)?)
     }
 
-    fn internal_add_edge(
+    fn resolve_node_and_type(
         &self,
-        t: EventTime,
-        src: VID,
-        dst: VID,
-        props: &[(usize, Prop)],
-        layer: usize,
-    ) -> Result<MaybeNew<EID>, Self::Error> {
-        self.mutable()?.internal_add_edge(t, src, dst, props, layer)
+        id: NodeRef,
+        node_type: Option<&str>,
+    ) -> Result<(VID, usize), Self::Error> {
+        self.mutable()?
+            .resolve_node_and_type(id, node_type)
+            .map_err(MutationError::from)
     }
 
-    fn internal_add_edge_update(
-        &self,
-        t: EventTime,
-        edge: EID,
-        props: &[(usize, Prop)],
-        layer: usize,
-    ) -> Result<(), Self::Error> {
+    unsafe fn bulk_load_resolve_node(&self, id: GidRef<'_>) -> Result<VID, Self::Error> {
         self.mutable()?
-            .internal_add_edge_update(t, edge, props, layer)
+            .bulk_load_resolve_node(id)
+            .map_err(MutationError::from)
+    }
+
+    fn atomic_add_node(&self, node: NodeRef) -> Result<AtomicAddNode<'_>, Self::Error> {
+        self.mutable()?.atomic_add_node(node)
     }
 }
 
@@ -363,34 +295,25 @@ where
     G::Base: InternalAdditionOps,
 {
     type Error = <G::Base as InternalAdditionOps>::Error;
+    type WS<'a>
+        = <G::Base as InternalAdditionOps>::WS<'a>
+    where
+        <G as Base>::Base: 'a,
+        G: 'a;
+
+    type AtomicAddEdge<'a>
+        = <G::Base as InternalAdditionOps>::AtomicAddEdge<'a>
+    where
+        <G as Base>::Base: 'a,
+        G: 'a;
 
     #[inline]
-    fn write_lock(&self) -> Result<WriteLockedGraph<'_>, Self::Error> {
+    fn write_lock(&self) -> Result<WriteLockedGraph<'_, Extension>, Self::Error> {
         self.base().write_lock()
     }
 
     #[inline]
-    fn write_lock_nodes(&self) -> Result<WriteLockedNodes<'_>, Self::Error> {
-        self.base().write_lock_nodes()
-    }
-
-    #[inline]
-    fn write_lock_edges(&self) -> Result<WriteLockedEdges<'_>, Self::Error> {
-        self.base().write_lock_edges()
-    }
-
-    #[inline]
-    fn next_event_id(&self) -> Result<usize, Self::Error> {
-        self.base().next_event_id()
-    }
-
-    #[inline]
-    fn reserve_event_ids(&self, num_ids: usize) -> Result<usize, Self::Error> {
-        self.base().reserve_event_ids(num_ids)
-    }
-
-    #[inline]
-    fn resolve_layer(&self, layer: Option<&str>) -> Result<MaybeNew<usize>, Self::Error> {
+    fn resolve_layer(&self, layer: Option<&str>) -> Result<MaybeNew<LayerId>, Self::Error> {
         self.base().resolve_layer(layer)
     }
 
@@ -400,79 +323,82 @@ where
     }
 
     #[inline]
-    fn set_node(&self, gid: GidRef, vid: VID) -> Result<(), Self::Error> {
-        self.base().set_node(gid, vid)
+    fn resolve_and_update_node_and_type(
+        &self,
+        id: NodeRef,
+        node_type: Option<&str>,
+    ) -> Result<MaybeNew<(MaybeNew<VID>, MaybeNew<usize>)>, Self::Error> {
+        self.base().resolve_and_update_node_and_type(id, node_type)
     }
 
     #[inline]
-    fn resolve_node_and_type(
+    fn write_session(&self) -> Result<Self::WS<'_>, Self::Error> {
+        self.base().write_session()
+    }
+
+    #[inline]
+    fn atomic_add_edge(
         &self,
-        id: NodeRef,
-        node_type: &str,
-    ) -> Result<MaybeNew<(MaybeNew<VID>, MaybeNew<usize>)>, Self::Error> {
-        self.base().resolve_node_and_type(id, node_type)
+        src: NodeRef,
+        dst: NodeRef,
+        e_id: Option<EID>,
+    ) -> Result<Self::AtomicAddEdge<'_>, Self::Error> {
+        self.base().atomic_add_edge(src, dst, e_id)
     }
 
     #[inline]
-    fn resolve_graph_property(
+    fn internal_add_node(
         &self,
-        prop: &str,
-        dtype: PropType,
-        is_static: bool,
-    ) -> Result<MaybeNew<usize>, Self::Error> {
-        self.base().resolve_graph_property(prop, dtype, is_static)
+        t: EventTime,
+        v: VID,
+        props: Vec<(usize, Prop)>,
+        layer_id: LayerId,
+    ) -> Result<NodeWriterT<'_>, Self::Error> {
+        self.base().internal_add_node(t, v, props, layer_id)
     }
 
     #[inline]
-    fn resolve_node_property(
+    fn validate_props<PN: AsRef<str>>(
         &self,
-        prop: &str,
-        dtype: PropType,
         is_static: bool,
-    ) -> Result<MaybeNew<usize>, Self::Error> {
-        self.base().resolve_node_property(prop, dtype, is_static)
+        meta: &Meta,
+        prop: impl Iterator<Item = (PN, Prop)>,
+    ) -> Result<Vec<(usize, Prop)>, Self::Error> {
+        self.base().validate_props(is_static, meta, prop)
     }
 
     #[inline]
-    fn resolve_edge_property(
+    fn validate_props_with_status<PN: AsRef<str>>(
         &self,
-        prop: &str,
-        dtype: PropType,
         is_static: bool,
-    ) -> Result<MaybeNew<usize>, Self::Error> {
-        self.base().resolve_edge_property(prop, dtype, is_static)
+        meta: &Meta,
+        props: impl Iterator<Item = (PN, Prop)>,
+    ) -> Result<Vec<MaybeNew<(PN, usize, Prop)>>, Self::Error> {
+        self.base()
+            .validate_props_with_status(is_static, meta, props)
     }
 
     #[inline]
-    fn internal_add_node(
+    fn validate_gids<'a>(
         &self,
-        t: EventTime,
-        v: VID,
-        props: &[(usize, Prop)],
+        gids: impl IntoIterator<Item = GidRef<'a>>,
     ) -> Result<(), Self::Error> {
-        self.base().internal_add_node(t, v, props)
+        self.base().validate_gids(gids)
     }
 
-    #[inline]
-    fn internal_add_edge(
+    fn resolve_node_and_type(
         &self,
-        t: EventTime,
-        src: VID,
-        dst: VID,
-        props: &[(usize, Prop)],
-        layer: usize,
-    ) -> Result<MaybeNew<EID>, Self::Error> {
-        self.base().internal_add_edge(t, src, dst, props, layer)
+        id: NodeRef,
+        node_type: Option<&str>,
+    ) -> Result<(VID, usize), Self::Error> {
+        self.base().resolve_node_and_type(id, node_type)
     }
 
-    #[inline]
-    fn internal_add_edge_update(
-        &self,
-        t: EventTime,
-        edge: EID,
-        props: &[(usize, Prop)],
-        layer: usize,
-    ) -> Result<(), Self::Error> {
-        self.base().internal_add_edge_update(t, edge, props, layer)
+    unsafe fn bulk_load_resolve_node(&self, id: GidRef<'_>) -> Result<VID, Self::Error> {
+        self.base().bulk_load_resolve_node(id)
+    }
+
+    fn atomic_add_node(&self, node: NodeRef) -> Result<AtomicAddNode<'_>, Self::Error> {
+        self.base().atomic_add_node(node)
     }
 }
diff --git a/raphtory-storage/src/mutation/addition_ops_ext.rs b/raphtory-storage/src/mutation/addition_ops_ext.rs
new file mode 100644
index 0000000000..30c589b426
--- /dev/null
+++ b/raphtory-storage/src/mutation/addition_ops_ext.rs
@@ -0,0 +1,766 @@
+use crate::{
+    durability_ops::DurabilityOps,
+    mutation::{
+        addition_ops::{EdgeWriteLock, InternalAdditionOps, NodeWriteLock, SessionAdditionOps},
+        MutationError, NodeWriterT,
+    },
+    recovery_ops::RecoveryOps,
+};
+use db4_graph::{TemporalGraph, WriteLockedGraph};
+use raphtory_api::core::{
+    entities::{
+        properties::{
+            meta::{Meta, DEFAULT_NODE_TYPE_ID, NODE_TYPE_IDX, STATIC_GRAPH_LAYER_ID},
+            prop::{Prop, PropType, PropUnwrap},
+        },
+        LayerId,
+    },
+    storage::dict_mapper::MaybeNew,
+};
+use raphtory_core::{
+    entities::{
+        graph::tgraph::TooManyLayers,
+        nodes::node_ref::{AsNodeRef, NodeRef},
+        GidRef, EID, MAX_LAYER, VID,
+    },
+    storage::timeindex::EventTime,
+};
+use std::sync::atomic::Ordering;
+use storage::{
+    api::{edges::EdgeSegmentOps, graph_props::GraphPropSegmentOps, nodes::NodeSegmentOps},
+    error::StorageError,
+    pages::{
+        node_page::writer::{node_info_as_props, NodeWriters},
+        resolve_pos,
+        session::EdgeWriteSession,
+    },
+    persist::{config::ConfigOps, strategy::PersistenceStrategy},
+    properties::props_meta_writer::PropsMetaWriter,
+    resolver::{GIDResolverOps, Initialiser, MaybeInit},
+    transaction::TransactionManager,
+    wal::LSN,
+    ControlFile, Extension, LocalPOS, Wal, ES, GS, NS,
+};
+
+pub struct AtomicAddEdge<'a, EXT>
+where
+    EXT: PersistenceStrategy<NS = NS<EXT>, ES = ES<EXT>, GS = GS<EXT>>,
+    NS<EXT>: NodeSegmentOps<Extension = EXT>,
+    ES<EXT>: EdgeSegmentOps<Extension = EXT>,
+    GS<EXT>: GraphPropSegmentOps<Extension = EXT>,
+{
+    static_session: EdgeWriteSession<'a, NS<EXT>, ES<EXT>, GS<EXT>, EXT>,
+    src: MaybeNew<VID>,
+    dst: MaybeNew<VID>,
+    eid: MaybeNew<EID>,
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct UnlockedSession<'a> {
+    graph: &'a TemporalGraph<Extension>,
+}
+
+impl<'a, EXT> EdgeWriteLock for AtomicAddEdge<'a, EXT>
+where
+    EXT: PersistenceStrategy<NS = NS<EXT>, ES = ES<EXT>, GS = GS<EXT>>,
+    NS<EXT>: NodeSegmentOps<Extension = EXT>,
+    ES<EXT>: EdgeSegmentOps<Extension = EXT>,
+    GS<EXT>: GraphPropSegmentOps<Extension = EXT>,
+{
+    fn internal_add_update(
+        &mut self,
+        t: EventTime,
+        layer: LayerId,
+        props: impl IntoIterator<Item = (usize, Prop)>,
+    ) {
+        self.static_session.add_edge_into_layer(
+            t,
+            self.src.inner(),
+            self.dst.inner(),
+            self.eid.map(|eid| eid.with_layer(layer)),
+            props,
+        );
+    }
+
+    fn internal_delete_edge(&mut self, t: EventTime, layer: LayerId) {
+        self.static_session.delete_edge_from_layer(
+            t,
+            self.src.inner(),
+            self.dst.inner(),
+            self.eid.map(|eid| eid.with_layer_deletion(layer)),
+        );
+    }
+
+    fn set_lsn(&mut self, lsn: LSN) {
+        self.static_session.set_lsn(lsn);
+    }
+
+    fn src(&self) -> MaybeNew<VID> {
+        self.src
+    }
+
+    fn dst(&self) -> MaybeNew<VID> {
+        self.dst
+    }
+
+    fn eid(&self) -> MaybeNew<EID> {
+        self.eid
+    }
+}
+
+impl<'a> SessionAdditionOps for UnlockedSession<'a> {
+    type Error = MutationError;
+
+    fn read_event_id(&self) -> Result<usize, Self::Error> {
+        Ok(self.graph.storage().read_event_id())
+    }
+
+    fn set_event_id(&self, event_id: usize) -> Result<(), Self::Error> {
+        Ok(self.graph.storage().set_event_id(event_id))
+    }
+
+    fn next_event_id(&self) -> Result<usize, Self::Error> {
+        Ok(self.graph.storage().next_event_id())
+    }
+
+    fn reserve_event_ids(&self, num_ids: usize) -> Result<usize, Self::Error> {
+        let event_id = self.graph.storage().reserve_event_ids(num_ids);
+        Ok(event_id)
+    }
+
+    fn set_max_event_id(&self, value: usize) -> Result<usize, Self::Error> {
+        Ok(self.graph.storage().set_max_event_id(value))
+    }
+
+    fn set_node(&self, gid: GidRef, vid: VID) -> Result<(), Self::Error> {
+        Ok(self.graph.logical_to_physical.set(gid, vid)?)
+    }
+
+    fn resolve_graph_property(
+        &self,
+        prop: &str,
+        dtype: PropType,
+        is_static: bool,
+    ) -> Result<MaybeNew<usize>, Self::Error> {
+        Ok(self
+            .graph
+            .graph_props_meta()
+            .resolve_prop_id(prop, dtype, is_static)?)
+    }
+
+    fn resolve_node_property(
+        &self,
+        prop: &str,
+        dtype: PropType,
+        is_static: bool,
+    ) -> Result<MaybeNew<usize>, Self::Error> {
+        Ok(self
+            .graph
+            .node_meta()
+            .resolve_prop_id(prop, dtype, is_static)?)
+    }
+
+    fn resolve_edge_property(
+        &self,
+        prop: &str,
+        dtype: PropType,
+        is_static: bool,
+    ) -> Result<MaybeNew<usize>, Self::Error> {
+        Ok(self
+            .graph
+            .edge_meta()
+            .resolve_prop_id(prop, dtype, is_static)?)
+    }
+}
+
+#[derive(Debug)]
+pub struct AtomicAddNode<'a> {
+    writer: NodeWriterT<'a>,
+    vid: MaybeNew<VID>,
+}
+
+impl<'a> AtomicAddNode<'a> {
+    fn local_pos(&self) -> LocalPOS {
+        let (_, pos) = resolve_pos(self.vid.inner(), self.writer.mut_segment.max_page_len());
+        pos
+    }
+}
+
+impl<'a> NodeWriteLock for AtomicAddNode<'a> {
+    fn internal_add_update(
+        &mut self,
+        t: EventTime,
+        layer: LayerId,
+        props: impl IntoIterator<Item = (usize, Prop)>,
+    ) {
+        let pos = self.local_pos();
+        self.writer.add_props(t, pos, layer, props)
+    }
+
+    fn can_set_type(&self) -> bool {
+        self.vid.is_new() || self.get_type() == DEFAULT_NODE_TYPE_ID
+    }
+
+    fn get_type(&self) -> usize {
+        self.writer
+            .get_metadata(self.local_pos(), STATIC_GRAPH_LAYER_ID, NODE_TYPE_IDX)
+            .into_u64()
+            .map(|u| u as usize)
+            .unwrap_or(DEFAULT_NODE_TYPE_ID)
+    }
+
+    fn set_type(&mut self, node_type: usize) {
+        let pos = self.local_pos();
+        self.writer
+            .store_node_type(pos, STATIC_GRAPH_LAYER_ID, node_type)
+    }
+
+    fn set_lsn(&mut self, lsn: LSN) {
+        self.writer.mut_segment.set_lsn(lsn)
+    }
+
+    fn node(&self) -> MaybeNew<VID> {
+        self.vid
+    }
+}
+
+impl InternalAdditionOps for TemporalGraph {
+    type Error = MutationError;
+    type WS<'a> = UnlockedSession<'a>;
+    type AtomicAddEdge<'a> = AtomicAddEdge<'a, Extension>;
+
+    fn write_lock(&self) -> Result<WriteLockedGraph<'_, Extension>, Self::Error> {
+        let locked_g = self.write_locked_graph();
+        Ok(locked_g)
+    }
+
+    fn resolve_layer(&self, layer: Option<&str>) -> Result<MaybeNew<LayerId>, Self::Error> {
+        let id = self.edge_meta().get_or_create_layer_id(layer);
+        // TODO: we replicate the layer id in the node meta as well, perhaps layer meta should be common
+        if id.is_new() {
+            self.node_meta().layer_meta().set_id(
+                self.edge_meta().layer_meta().get_name(id.inner().0),
+                id.inner().0,
+            );
+        }
+        if let MaybeNew::New(id) = id {
+            if id.0 > MAX_LAYER {
+                Err(TooManyLayers)?;
+            }
+        }
+        Ok(id)
+    }
+
+    fn resolve_node(&self, id: NodeRef) -> Result<MaybeNew<VID>, Self::Error> {
+        match id {
+            NodeRef::External(id) => {
+                let id = match self.logical_to_physical.get_or_init(id)? {
+                    MaybeInit::VID(vid) => MaybeNew::Existing(vid),
+                    MaybeInit::Init(init) => {
+                        let (seg, pos) = self.storage().nodes().reserve_free_pos(
+                            self.round_robin_counter.fetch_add(1, Ordering::Relaxed),
+                        );
+                        let vid = pos.as_vid(seg, self.extension().config().max_node_page_len());
+                        init.init(vid)?;
+                        MaybeNew::New(vid)
+                    }
+                };
+                Ok(id)
+            }
+            NodeRef::Internal(id) => Ok(MaybeNew::Existing(id)),
+        }
+    }
+
+    fn resolve_and_update_node_and_type(
+        &self,
+        id: NodeRef,
+        node_type: Option<&str>,
+    ) -> Result<MaybeNew<(MaybeNew<VID>, MaybeNew<usize>)>, Self::Error> {
+        let vid = self.resolve_node(id)?;
+        let (segment_id, local_pos) = self.storage().nodes().resolve_pos(vid.inner());
+        let mut writer = self.storage().nodes().writer(segment_id);
+
+        let node_type_id = match node_type {
+            None => {
+                writer.update_c_props(
+                    local_pos,
+                    STATIC_GRAPH_LAYER_ID,
+                    node_info_as_props(id.as_gid_ref(), None),
+                );
+                MaybeNew::Existing(0)
+            }
+            Some(node_type) => {
+                let old_type_id = writer
+                    .get_metadata(local_pos, STATIC_GRAPH_LAYER_ID, NODE_TYPE_IDX)
+                    .into_u64();
+
+                match old_type_id {
+                    None => {
+                        let node_type_id = self.node_meta().get_or_create_node_type_id(node_type);
+
+                        writer.update_c_props(
+                            local_pos,
+                            STATIC_GRAPH_LAYER_ID,
+                            node_info_as_props(
+                                id.as_gid_ref(),
+                                Some(node_type_id.inner()).filter(|&id| id != 0),
+                            ),
+                        );
+
+                        node_type_id
+                    }
+                    Some(old_type_id) => MaybeNew::Existing(
+                        self.node_meta()
+                            .get_node_type_id(node_type)
+                            .filter(|&new_id| new_id == old_type_id as usize)
+                            .ok_or(MutationError::NodeTypeError)?,
+                    ),
+                }
+            }
+        };
+
+        Ok(vid.map(|_| (vid, node_type_id)))
+    }
+
+    fn resolve_node_and_type(
+        &self,
+        id: NodeRef,
+        node_type: Option<&str>,
+    ) -> Result<(VID, usize), Self::Error> {
+        let vid = self.resolve_node(id)?.inner();
+        let node_type_id = match node_type {
+            Some(node_type) => self
+                .node_meta()
+                .get_or_create_node_type_id(node_type)
+                .inner(),
+            None => DEFAULT_NODE_TYPE_ID,
+        };
+        Ok((vid, node_type_id))
+    }
+
+    unsafe fn bulk_load_resolve_node(&self, id: GidRef<'_>) -> Result<VID, Self::Error> {
+        let vid = match self.logical_to_physical.get(id) {
+            Some(vid) => vid,
+            None => {
+                let (seg, pos) = self
+                    .storage()
+                    .nodes()
+                    .reserve_free_pos(self.round_robin_counter.fetch_add(1, Ordering::Relaxed));
+                let new_vid = pos.as_vid(seg, self.extension().config().max_node_page_len());
+                self.logical_to_physical.set(id, new_vid)?;
+                new_vid
+            }
+        };
+
+        Ok(vid)
+    }
+
+    fn validate_gids<'a>(
+        &self,
+        gids: impl IntoIterator<Item = GidRef<'a>>,
+    ) -> Result<(), Self::Error> {
+        self.logical_to_physical.validate_gids(gids)?;
+        Ok(())
+    }
+
+    fn write_session(&self) -> Result<Self::WS<'_>, Self::Error> {
+        Ok(UnlockedSession { graph: self })
+    }
+
+    fn atomic_add_edge(
+        &self,
+        src: NodeRef,
+        dst: NodeRef,
+        e_id: Option<EID>,
+    ) -> Result<Self::AtomicAddEdge<'_>, Self::Error> {
+        let nodes = self.storage().nodes();
+
+        let (src_init, dst_init) = match (src, dst) {
+            (NodeRef::Internal(src_id), NodeRef::Internal(dst_id)) => {
+                (MaybeInit::VID(src_id), Some(MaybeInit::VID(dst_id)))
+            }
+            (NodeRef::Internal(src_id), NodeRef::External(dst_gid)) => (
+                MaybeInit::VID(src_id),
+                Some(self.logical_to_physical.get_or_init(dst_gid)?),
+            ),
+            (NodeRef::External(src_gid), NodeRef::Internal(dst_id)) => (
+                self.logical_to_physical.get_or_init(src_gid)?,
+                Some(MaybeInit::VID(dst_id)),
+            ),
+            (NodeRef::External(src_gid), NodeRef::External(dst_gid)) => {
+                // resolve the smaller id first to avoid deadlocks when adding the same edge in both directions
+                match src_gid.cmp(&dst_gid) {
+                    std::cmp::Ordering::Less => (
+                        self.logical_to_physical.get_or_init(src_gid)?,
+                        Some(self.logical_to_physical.get_or_init(dst_gid)?),
+                    ),
+                    std::cmp::Ordering::Equal => {
+                        (self.logical_to_physical.get_or_init(src_gid)?, None)
+                    }
+                    std::cmp::Ordering::Greater => {
+                        let dst_init = self.logical_to_physical.get_or_init(dst_gid)?;
+                        (
+                            self.logical_to_physical.get_or_init(src_gid)?,
+                            Some(dst_init),
+                        )
+                    }
+                }
+            }
+        };
+
+        let dst_init = dst_init.filter(|dst_init| dst_init != &src_init);
+
+        let (mut node_writers, src_id, dst_id) = match (src_init, dst_init) {
+            (src_init, None) => {
+                // self-loop
+                match src_init {
+                    MaybeInit::VID(vid) => {
+                        let (src_chunk, _) = nodes.resolve_pos(vid);
+                        let writer = nodes.writer(src_chunk);
+                        (
+                            NodeWriters {
+                                src: writer,
+                                dst: None,
+                            },
+                            MaybeNew::Existing(vid),
+                            MaybeNew::Existing(vid),
+                        )
+                    }
+                    MaybeInit::Init(init) => {
+                        let (pos, writer) = nodes.reserve_and_lock_segment(
+                            self.round_robin_counter.fetch_add(1, Ordering::Relaxed),
+                            1,
+                        );
+                        let vid =
+                            pos.as_vid(writer.page.segment_id(), writer.mut_segment.max_page_len());
+                        init.init(vid)?;
+                        (
+                            NodeWriters {
+                                src: writer,
+                                dst: None,
+                            },
+                            MaybeNew::New(vid),
+                            MaybeNew::New(vid),
+                        )
+                    }
+                }
+            }
+            (MaybeInit::Init(src_init), Some(MaybeInit::Init(dst_init))) => {
+                // both new, put them in the same segment
+                let (pos, writer) = nodes.reserve_and_lock_segment(
+                    self.round_robin_counter.fetch_add(1, Ordering::Relaxed),
+                    2,
+                );
+                let src_id =
+                    pos.as_vid(writer.page.segment_id(), writer.mut_segment.max_page_len());
+                let dst_id = LocalPOS(pos.0 + 1)
+                    .as_vid(writer.page.segment_id(), writer.mut_segment.max_page_len());
+                src_init.init(src_id)?;
+                dst_init.init(dst_id)?;
+                (
+                    NodeWriters {
+                        src: writer,
+                        dst: None,
+                    },
+                    MaybeNew::New(src_id),
+                    MaybeNew::New(dst_id),
+                )
+            }
+            (MaybeInit::Init(src_init), Some(MaybeInit::VID(dst_id))) => {
+                let (dst_chunk, _) = nodes.resolve_pos(dst_id);
+                let mut dst_writer = nodes.writer(dst_chunk);
+                match nodes.reserve_segment_row(dst_writer.page) {
+                    None => {
+                        let (src_id, src_writer) = dst_writer.unlocked(|| {
+                            // existing segment is full, need to get a new one, unlock dst_writer such that the segment can be evicted from the free segments
+                            let (src_pos, src_writer) = nodes.reserve_and_lock_segment(
+                                self.round_robin_counter.fetch_add(1, Ordering::Relaxed),
+                                1,
+                            );
+                            let src_id = src_pos.as_vid(
+                                src_writer.page.segment_id(),
+                                src_writer.mut_segment.max_page_len(),
+                            );
+                            src_init.init(src_id)?;
+                            Ok::<_, StorageError>((src_id, src_writer))
+                        })?;
+                        (
+                            NodeWriters {
+                                src: src_writer,
+                                dst: Some(dst_writer),
+                            },
+                            MaybeNew::New(src_id),
+                            MaybeNew::Existing(dst_id),
+                        )
+                    }
+                    Some(src_pos) => {
+                        let src_id = LocalPOS(src_pos).as_vid(
+                            dst_writer.page.segment_id(),
+                            dst_writer.mut_segment.max_page_len(),
+                        );
+                        src_init.init(src_id)?;
+                        (
+                            NodeWriters {
+                                src: dst_writer,
+                                dst: None,
+                            },
+                            MaybeNew::New(src_id),
+                            MaybeNew::Existing(dst_id),
+                        )
+                    }
+                }
+            }
+            (MaybeInit::VID(src_id), Some(MaybeInit::Init(dst_init))) => {
+                let (src_chunk, _) = nodes.resolve_pos(src_id);
+                let mut src_writer = nodes.writer(src_chunk);
+                match nodes.reserve_segment_row(src_writer.page) {
+                    None => {
+                        let (dst_id, dst_writer) = src_writer.unlocked(|| {
+                            // unlocked to make sure we can evict this segment from the free segments to avoid deadlocking
+                            let (dst_pos, dst_writer) = nodes.reserve_and_lock_segment(
+                                self.round_robin_counter.fetch_add(1, Ordering::Relaxed),
+                                1,
+                            );
+                            let dst_id = dst_pos.as_vid(
+                                dst_writer.page.segment_id(),
+                                dst_writer.mut_segment.max_page_len(),
+                            );
+                            dst_init.init(dst_id)?;
+                            Ok::<_, StorageError>((dst_id, dst_writer))
+                        })?;
+                        (
+                            NodeWriters {
+                                src: src_writer,
+                                dst: Some(dst_writer),
+                            },
+                            MaybeNew::Existing(src_id),
+                            MaybeNew::New(dst_id),
+                        )
+                    }
+                    Some(dst_pos) => {
+                        let dst_id = LocalPOS(dst_pos).as_vid(
+                            src_writer.page.segment_id(),
+                            src_writer.mut_segment.max_page_len(),
+                        );
+                        dst_init.init(dst_id)?;
+                        (
+                            NodeWriters {
+                                src: src_writer,
+                                dst: None,
+                            },
+                            MaybeNew::Existing(src_id),
+                            MaybeNew::New(dst_id),
+                        )
+                    }
+                }
+            }
+            (MaybeInit::VID(src_id), Some(MaybeInit::VID(dst_id))) => {
+                let (src_chunk, _) = nodes.resolve_pos(src_id);
+                let (dst_chunk, _) = nodes.resolve_pos(dst_id);
+                if src_chunk == dst_chunk {
+                    let writer = nodes.writer(src_chunk);
+                    (
+                        NodeWriters {
+                            src: writer,
+                            dst: None,
+                        },
+                        MaybeNew::Existing(src_id),
+                        MaybeNew::Existing(dst_id),
+                    )
+                } else {
+                    let node_writers = if src_chunk < dst_chunk {
+                        loop {
+                            if let Some(src_writer) = nodes.try_writer(src_chunk) {
+                                if let Some(dst_writer) = nodes.try_writer(dst_chunk) {
+                                    break NodeWriters {
+                                        src: src_writer,
+                                        dst: Some(dst_writer),
+                                    };
+                                }
+                            }
+                        }
+                    } else {
+                        loop {
+                            if let Some(dst_writer) = nodes.try_writer(dst_chunk) {
+                                if let Some(src_writer) = nodes.try_writer(src_chunk) {
+                                    break NodeWriters {
+                                        src: src_writer,
+                                        dst: Some(dst_writer),
+                                    };
+                                }
+                            }
+                        }
+                    };
+                    (
+                        node_writers,
+                        MaybeNew::Existing(src_id),
+                        MaybeNew::Existing(dst_id),
+                    )
+                }
+            }
+        };
+
+        let (_, src_pos) = nodes.resolve_pos(src_id.inner());
+        let (_, dst_pos) = nodes.resolve_pos(dst_id.inner());
+
+        if src_id.is_new() {
+            if let Some(gid) = src.as_gid_ref() {
+                node_writers.get_mut_src().store_node_id(
+                    src_pos,
+                    STATIC_GRAPH_LAYER_ID,
+                    gid.to_owned(),
+                );
+            }
+        }
+
+        if dst_id.is_new() {
+            if let Some(gid) = dst.as_gid_ref() {
+                node_writers.get_mut_dst().store_node_id(
+                    dst_pos,
+                    STATIC_GRAPH_LAYER_ID,
+                    gid.to_owned(),
+                );
+            }
+        }
+
+        let existing_eid =
+            node_writers
+                .src
+                .get_out_edge(src_pos, dst_id.inner(), STATIC_GRAPH_LAYER_ID);
+
+        let (edge_id, edge_writer) = match e_id.or(existing_eid) {
+            Some(edge_id) => (
+                MaybeNew::Existing(edge_id),
+                self.storage().edge_writer(edge_id),
+            ),
+            None => {
+                let mut edge_writer = self.storage().get_free_writer();
+                let edge_pos = None;
+                let already_counted = false;
+                let edge_pos = edge_writer.add_static_edge(
+                    edge_pos,
+                    src_id.inner(),
+                    dst_id.inner(),
+                    already_counted,
+                );
+                let edge_id =
+                    edge_pos.as_eid(edge_writer.segment_id(), edge_writer.writer.max_page_len());
+
+                node_writers.get_mut_src().add_static_outbound_edge(
+                    src_pos,
+                    dst_id.inner(),
+                    edge_id,
+                );
+                node_writers.get_mut_dst().add_static_inbound_edge(
+                    dst_pos,
+                    src_id.inner(),
+                    edge_id,
+                );
+                (MaybeNew::New(edge_id), edge_writer)
+            }
+        };
+
+        Ok(AtomicAddEdge {
+            static_session: EdgeWriteSession::new(node_writers, edge_writer, self.storage()),
+            src: src_id,
+            dst: dst_id,
+            eid: edge_id,
+        })
+    }
+
+    fn atomic_add_node(&self, node: NodeRef) -> Result<AtomicAddNode<'_>, Self::Error> {
+        let node_vid = match node {
+            NodeRef::Internal(vid) => vid,
+            NodeRef::External(gid) => match self.logical_to_physical.get_or_init(gid)? {
+                MaybeInit::VID(vid) => vid,
+                MaybeInit::Init(init) => {
+                    let (pos, mut writer) = self.storage().nodes().reserve_and_lock_segment(
+                        self.round_robin_counter.fetch_add(1, Ordering::Relaxed),
+                        1,
+                    );
+                    writer.store_node_id(pos, STATIC_GRAPH_LAYER_ID, gid.to_owned());
+                    let vid =
+                        pos.as_vid(writer.page.segment_id(), writer.mut_segment.max_page_len());
+                    init.init(vid)?;
+                    return Ok(AtomicAddNode {
+                        writer,
+                        vid: MaybeNew::New(vid),
+                    });
+                }
+            },
+        };
+        let (segment_id, _) = self.storage().nodes().resolve_pos(node_vid);
+        let writer = self.storage().node_writer(segment_id);
+        Ok(AtomicAddNode {
+            writer,
+            vid: MaybeNew::Existing(node_vid),
+        })
+    }
+
+    fn internal_add_node(
+        &self,
+        t: EventTime,
+        v: VID,
+        props: Vec<(usize, Prop)>,
+        layer_id: LayerId,
+    ) -> Result<NodeWriterT<'_>, Self::Error> {
+        let (segment, node_pos) = self.storage().nodes().resolve_pos(v);
+        let mut node_writer = self.storage().node_writer(segment);
+        node_writer.add_props(t, node_pos, layer_id, props);
+        Ok(node_writer)
+    }
+
+    fn validate_props<PN: AsRef<str>>(
+        &self,
+        is_static: bool,
+        meta: &Meta,
+        props: impl Iterator<Item = (PN, Prop)>,
+    ) -> Result<Vec<(usize, Prop)>, Self::Error> {
+        if is_static {
+            let prop_ids = PropsMetaWriter::constant(meta, props)
+                .and_then(|pmw| pmw.into_props_const())
+                .map_err(MutationError::StorageError)?;
+            Ok(prop_ids)
+        } else {
+            let prop_ids = PropsMetaWriter::temporal(meta, props)
+                .and_then(|pmw| pmw.into_props_temporal())
+                .map_err(MutationError::StorageError)?;
+            Ok(prop_ids)
+        }
+    }
+
+    fn validate_props_with_status<PN: AsRef<str>>(
+        &self,
+        is_static: bool,
+        meta: &Meta,
+        props: impl Iterator<Item = (PN, Prop)>,
+    ) -> Result<Vec<MaybeNew<(PN, usize, Prop)>>, Self::Error> {
+        if is_static {
+            let prop_ids = PropsMetaWriter::constant(meta, props)
+                .and_then(|pmw| pmw.into_props_const_with_status())
+                .map_err(MutationError::StorageError)?;
+            Ok(prop_ids)
+        } else {
+            let prop_ids = PropsMetaWriter::temporal(meta, props)
+                .and_then(|pmw| pmw.into_props_temporal_with_status())
+                .map_err(MutationError::StorageError)?;
+            Ok(prop_ids)
+        }
+    }
+}
+
+impl DurabilityOps for TemporalGraph {
+    fn transaction_manager(&self) -> Result<&TransactionManager, MutationError> {
+        Ok(&self.transaction_manager)
+    }
+
+    fn wal(&self) -> Result<&Wal, MutationError> {
+        Ok(&self.extension().wal())
+    }
+
+    fn control_file(&self) -> Result<&ControlFile, MutationError> {
+        Ok(&self.extension().control_file())
+    }
+}
+
+impl RecoveryOps for TemporalGraph {}
diff --git a/raphtory-storage/src/mutation/deletion_ops.rs b/raphtory-storage/src/mutation/deletion_ops.rs
deleted file mode 100644
index fce1ab6bbb..0000000000
--- a/raphtory-storage/src/mutation/deletion_ops.rs
+++ /dev/null
@@ -1,110 +0,0 @@
-use crate::{graph::graph::GraphStorage, mutation::MutationError};
-use raphtory_api::{
-    core::{
-        entities::{EID, VID},
-        storage::{dict_mapper::MaybeNew, timeindex::EventTime},
-    },
-    inherit::Base,
-};
-use raphtory_core::entities::graph::tgraph::TemporalGraph;
-
-pub trait InternalDeletionOps {
-    type Error: From<MutationError>;
-    fn internal_delete_edge(
-        &self,
-        t: EventTime,
-        src: VID,
-        dst: VID,
-        layer: usize,
-    ) -> Result<MaybeNew<EID>, Self::Error>;
-    fn internal_delete_existing_edge(
-        &self,
-        t: EventTime,
-        eid: EID,
-        layer: usize,
-    ) -> Result<(), Self::Error>;
-}
-
-impl InternalDeletionOps for TemporalGraph {
-    type Error = MutationError;
-
-    fn internal_delete_edge(
-        &self,
-        t: EventTime,
-        src: VID,
-        dst: VID,
-        layer: usize,
-    ) -> Result<MaybeNew<EID>, Self::Error> {
-        let edge = self.link_nodes(src, dst, t, layer, true);
-        Ok(edge.map(|mut edge| {
-            let mut edge = edge.as_mut();
-            edge.deletions_mut(layer).insert(t);
-            edge.eid()
-        }))
-    }
-
-    fn internal_delete_existing_edge(
-        &self,
-        t: EventTime,
-        eid: EID,
-        layer: usize,
-    ) -> Result<(), Self::Error> {
-        let mut edge = self.link_edge(eid, t, layer, true);
-        let mut edge = edge.as_mut();
-        edge.deletions_mut(layer).insert(t);
-        Ok(())
-    }
-}
-
-impl InternalDeletionOps for GraphStorage {
-    type Error = MutationError;
-
-    fn internal_delete_edge(
-        &self,
-        t: EventTime,
-        src: VID,
-        dst: VID,
-        layer: usize,
-    ) -> Result<MaybeNew<EID>, Self::Error> {
-        self.mutable()?.internal_delete_edge(t, src, dst, layer)
-    }
-
-    fn internal_delete_existing_edge(
-        &self,
-        t: EventTime,
-        eid: EID,
-        layer: usize,
-    ) -> Result<(), Self::Error> {
-        self.mutable()?.internal_delete_existing_edge(t, eid, layer)
-    }
-}
-
-pub trait InheritDeletionOps: Base {}
-
-impl<G: InheritDeletionOps> InternalDeletionOps for G
-where
-    G::Base: InternalDeletionOps,
-{
-    type Error = <G::Base as InternalDeletionOps>::Error;
-
-    #[inline]
-    fn internal_delete_edge(
-        &self,
-        t: EventTime,
-        src: VID,
-        dst: VID,
-        layer: usize,
-    ) -> Result<MaybeNew<EID>, Self::Error> {
-        self.base().internal_delete_edge(t, src, dst, layer)
-    }
-
-    #[inline]
-    fn internal_delete_existing_edge(
-        &self,
-        t: EventTime,
-        eid: EID,
-        layer: usize,
-    ) -> Result<(), Self::Error> {
-        self.base().internal_delete_existing_edge(t, eid, layer)
-    }
-}
diff --git a/raphtory-storage/src/mutation/mod.rs b/raphtory-storage/src/mutation/mod.rs
index e93605c42b..7b8b5579fb 100644
--- a/raphtory-storage/src/mutation/mod.rs
+++ b/raphtory-storage/src/mutation/mod.rs
@@ -2,28 +2,42 @@ use crate::{
     core_ops::CoreGraphOps,
     graph::graph::Immutable,
     mutation::{
-        addition_ops::InheritAdditionOps, deletion_ops::InheritDeletionOps,
-        property_addition_ops::InheritPropertyAdditionOps,
+        addition_ops::InheritAdditionOps, property_addition_ops::InheritPropertyAdditionOps,
     },
 };
+use parking_lot::RwLockWriteGuard;
 use raphtory_api::{
     core::entities::properties::prop::{InvalidBigDecimal, PropError},
     inherit::Base,
 };
 use raphtory_core::entities::{
-    graph::{logical_to_physical::InvalidNodeId, tgraph::TooManyLayers},
+    graph::tgraph::TooManyLayers,
     properties::{
         props::{MetadataError, TPropError},
         tprop::IllegalPropType,
     },
 };
 use std::sync::Arc;
+use storage::{
+    error::StorageError,
+    pages::{
+        edge_page::writer::EdgeWriter, graph_prop_page::writer::GraphPropWriter,
+        node_page::writer::NodeWriter,
+    },
+    resolver::mapping_resolver::InvalidNodeId,
+    segments::{edge::segment::MemEdgeSegment, node::segment::MemNodeSegment},
+    Extension, ES, GS, NS,
+};
 use thiserror::Error;
 
 pub mod addition_ops;
-pub mod deletion_ops;
+pub mod addition_ops_ext;
 pub mod property_addition_ops;
 
+pub type NodeWriterT<'a> = NodeWriter<'a, RwLockWriteGuard<'a, MemNodeSegment>, NS<Extension>>;
+pub type EdgeWriterT<'a> = EdgeWriter<'a, RwLockWriteGuard<'a, MemEdgeSegment>, ES<Extension>>;
+pub type GraphPropWriterT<'a> = GraphPropWriter<'a, GS<Extension>>;
+
 #[derive(Error, Debug)]
 pub enum MutationError {
     #[error(transparent)]
@@ -50,12 +64,12 @@ pub enum MutationError {
         src: String,
         dst: String,
     },
+    #[error("Storage error: {0}")]
+    StorageError(#[from] StorageError),
 }
 
 pub trait InheritMutationOps: Base {}
 
 impl<G: InheritMutationOps> InheritAdditionOps for G {}
 impl<G: InheritMutationOps> InheritPropertyAdditionOps for G {}
-impl<G: InheritMutationOps> InheritDeletionOps for G {}
-
 impl<T: CoreGraphOps + ?Sized> InheritMutationOps for Arc<T> {}
diff --git a/raphtory-storage/src/mutation/property_addition_ops.rs b/raphtory-storage/src/mutation/property_addition_ops.rs
index af18b92fe4..6844dd293f 100644
--- a/raphtory-storage/src/mutation/property_addition_ops.rs
+++ b/raphtory-storage/src/mutation/property_addition_ops.rs
@@ -1,220 +1,221 @@
 use crate::{
-    graph::{graph::GraphStorage, nodes::node_storage_ops::NodeStorageOps},
-    mutation::MutationError,
+    graph::graph::GraphStorage,
+    mutation::{EdgeWriterT, GraphPropWriterT, MutationError, NodeWriterT},
 };
-use parking_lot::RwLockWriteGuard;
+use db4_graph::TemporalGraph;
 use raphtory_api::{
     core::{
         entities::{
-            properties::prop::{validate_prop, Prop},
-            EID, VID,
+            properties::{
+                meta::STATIC_GRAPH_LAYER_ID,
+                prop::{AsPropRef, Prop},
+            },
+            LayerId, EID, VID,
         },
         storage::timeindex::EventTime,
     },
     inherit::Base,
 };
-use raphtory_core::{
-    entities::graph::tgraph::TemporalGraph,
-    storage::{raw_edges::EdgeWGuard, EntryMut, NodeSlot},
-};
+use storage::Extension;
 
 pub trait InternalPropertyAdditionOps {
     type Error: From<MutationError>;
-    fn internal_add_properties(
+
+    fn internal_add_properties<P: AsPropRef>(
         &self,
         t: EventTime,
+        props: &[(usize, P)],
+    ) -> Result<GraphPropWriterT<'_>, Self::Error>;
+
+    fn internal_add_metadata<P: AsPropRef>(
+        &self,
+        props: &[(usize, P)],
+    ) -> Result<GraphPropWriterT<'_>, Self::Error>;
+
+    fn internal_update_metadata(
+        &self,
         props: &[(usize, Prop)],
-    ) -> Result<(), Self::Error>;
-    fn internal_add_metadata(&self, props: &[(usize, Prop)]) -> Result<(), Self::Error>;
-    fn internal_update_metadata(&self, props: &[(usize, Prop)]) -> Result<(), Self::Error>;
-    fn internal_add_node_metadata(
+    ) -> Result<GraphPropWriterT<'_>, Self::Error>;
+
+    fn internal_add_node_metadata<P: AsPropRef>(
         &self,
         vid: VID,
-        props: &[(usize, Prop)],
-    ) -> Result<EntryMut<'_, RwLockWriteGuard<'_, NodeSlot>>, Self::Error>;
+        props: Vec<(usize, P)>,
+    ) -> Result<NodeWriterT<'_>, Self::Error>;
+
     fn internal_update_node_metadata(
         &self,
         vid: VID,
-        props: &[(usize, Prop)],
-    ) -> Result<EntryMut<'_, RwLockWriteGuard<'_, NodeSlot>>, Self::Error>;
-    fn internal_add_edge_metadata(
+        props: Vec<(usize, Prop)>,
+    ) -> Result<NodeWriterT<'_>, Self::Error>;
+
+    fn internal_add_edge_metadata<P: AsPropRef>(
         &self,
         eid: EID,
-        layer: usize,
-        props: &[(usize, Prop)],
-    ) -> Result<EdgeWGuard<'_>, Self::Error>;
+        layer: LayerId,
+        props: Vec<(usize, P)>,
+    ) -> Result<EdgeWriterT<'_>, Self::Error>;
+
     fn internal_update_edge_metadata(
         &self,
         eid: EID,
-        layer: usize,
-        props: &[(usize, Prop)],
-    ) -> Result<EdgeWGuard<'_>, Self::Error>;
+        layer: LayerId,
+        props: Vec<(usize, Prop)>,
+    ) -> Result<EdgeWriterT<'_>, Self::Error>;
 }
 
-impl InternalPropertyAdditionOps for TemporalGraph {
+impl InternalPropertyAdditionOps for TemporalGraph<Extension> {
     type Error = MutationError;
-    fn internal_add_properties(
+
+    // FIXME: this can't fail
+    fn internal_add_properties<P: AsPropRef>(
         &self,
         t: EventTime,
-        props: &[(usize, Prop)],
-    ) -> Result<(), Self::Error> {
-        if !props.is_empty() {
-            for (prop_id, prop) in props {
-                let prop = self.process_prop_value(prop);
-                let prop = validate_prop(prop).map_err(MutationError::from)?;
-                self.graph_meta
-                    .add_prop(t, *prop_id, prop)
-                    .map_err(MutationError::from)?;
-            }
-            self.update_time(t);
-        }
-        Ok(())
+        props: &[(usize, P)],
+    ) -> Result<GraphPropWriterT<'_>, Self::Error> {
+        let mut writer = self.storage().graph_props().writer();
+
+        writer.add_properties(t, props.iter().map(|(id, prop)| (*id, prop.as_prop_ref())));
+
+        Ok(writer)
     }
 
-    fn internal_add_metadata(&self, props: &[(usize, Prop)]) -> Result<(), Self::Error> {
-        for (id, prop) in props {
-            let prop = self.process_prop_value(prop);
-            let prop = validate_prop(prop).map_err(MutationError::from)?;
-            self.graph_meta
-                .add_metadata(*id, prop)
-                .map_err(MutationError::from)?;
-        }
-        Ok(())
+    fn internal_add_metadata<P: AsPropRef>(
+        &self,
+        props: &[(usize, P)],
+    ) -> Result<GraphPropWriterT<'_>, Self::Error> {
+        let mut writer = self.storage().graph_props().writer();
+
+        writer.check_metadata(props)?;
+        writer.update_metadata(props.iter().map(|(id, prop)| (*id, prop.as_prop_ref())));
+
+        Ok(writer)
     }
 
-    fn internal_update_metadata(&self, props: &[(usize, Prop)]) -> Result<(), Self::Error> {
-        for (id, prop) in props {
-            let prop = self.process_prop_value(prop);
-            let prop = validate_prop(prop).map_err(MutationError::from)?;
-            self.graph_meta.update_metadata(*id, prop);
-        }
-        Ok(())
+    // FIXME: this can't fail
+    fn internal_update_metadata(
+        &self,
+        props: &[(usize, Prop)],
+    ) -> Result<GraphPropWriterT<'_>, Self::Error> {
+        let mut writer = self.storage().graph_props().writer();
+
+        writer.update_metadata(props.iter().map(|(id, prop)| (*id, prop.clone())));
+
+        Ok(writer)
     }
 
-    fn internal_add_node_metadata(
+    fn internal_add_node_metadata<P: AsPropRef>(
         &self,
         vid: VID,
-        props: &[(usize, Prop)],
-    ) -> Result<EntryMut<'_, RwLockWriteGuard<'_, NodeSlot>>, Self::Error> {
-        let mut node = self.storage.get_node_mut(vid);
-        for (prop_id, prop) in props {
-            let prop = self.process_prop_value(prop);
-            let prop = validate_prop(prop).map_err(MutationError::from)?;
-            node.as_mut()
-                .add_metadata(*prop_id, prop)
-                .map_err(MutationError::from)?;
-        }
-        Ok(node)
+        props: Vec<(usize, P)>,
+    ) -> Result<NodeWriterT<'_>, Self::Error> {
+        let (segment_id, node_pos) = self.storage().nodes().resolve_pos(vid);
+        let mut writer = self.storage().nodes().writer(segment_id);
+
+        writer.check_metadata(node_pos, STATIC_GRAPH_LAYER_ID, &props)?;
+        writer.update_c_props(node_pos, STATIC_GRAPH_LAYER_ID, props);
+
+        Ok(writer)
     }
 
     fn internal_update_node_metadata(
         &self,
         vid: VID,
-        props: &[(usize, Prop)],
-    ) -> Result<EntryMut<'_, RwLockWriteGuard<'_, NodeSlot>>, Self::Error> {
-        let mut node = self.storage.get_node_mut(vid);
-        for (prop_id, prop) in props {
-            let prop = self.process_prop_value(prop);
-            let prop = validate_prop(prop).map_err(MutationError::from)?;
-            node.as_mut()
-                .update_metadata(*prop_id, prop)
-                .map_err(MutationError::from)?;
-        }
-        Ok(node)
+        props: Vec<(usize, Prop)>,
+    ) -> Result<NodeWriterT<'_>, Self::Error> {
+        let (segment_id, node_pos) = self.storage().nodes().resolve_pos(vid);
+        let mut writer = self.storage().nodes().writer(segment_id);
+
+        writer.update_c_props(node_pos, STATIC_GRAPH_LAYER_ID, props);
+
+        Ok(writer)
     }
 
-    fn internal_add_edge_metadata(
+    fn internal_add_edge_metadata<P: AsPropRef>(
         &self,
         eid: EID,
-        layer: usize,
-        props: &[(usize, Prop)],
-    ) -> Result<EdgeWGuard<'_>, Self::Error> {
-        let mut edge = self.storage.get_edge_mut(eid);
-        let mut edge_mut = edge.as_mut();
-        if let Some(edge_layer) = edge_mut.get_layer_mut(layer) {
-            for (prop_id, prop) in props {
-                let prop = self.process_prop_value(prop);
-                let prop = validate_prop(prop).map_err(MutationError::from)?;
-                edge_layer
-                    .add_metadata(*prop_id, prop)
-                    .map_err(MutationError::from)?;
-            }
-            Ok(edge)
-        } else {
-            let layer = self.get_layer_name(layer).to_string();
-            let src = self.node(edge.as_ref().src()).as_ref().id().to_string();
-            let dst = self.node(edge.as_ref().dst()).as_ref().id().to_string();
-            Err(MutationError::InvalidEdgeLayer { layer, src, dst })
-        }
+        layer: LayerId,
+        props: Vec<(usize, P)>,
+    ) -> Result<EdgeWriterT<'_>, Self::Error> {
+        let (_, edge_pos) = self.storage().edges().resolve_pos(eid);
+        let mut writer = self.storage().edge_writer(eid);
+
+        let (src, dst) = writer.get_edge(layer, edge_pos).unwrap_or_else(|| {
+            panic!("Edge with EID {eid:?} not found in layer {layer}");
+        });
+
+        writer.check_metadata(edge_pos, layer, &props)?;
+        writer.update_c_props(edge_pos, src, dst, layer, props);
+
+        Ok(writer)
     }
 
     fn internal_update_edge_metadata(
         &self,
         eid: EID,
-        layer: usize,
-        props: &[(usize, Prop)],
-    ) -> Result<EdgeWGuard<'_>, Self::Error> {
-        let mut edge = self.storage.get_edge_mut(eid);
-        let mut edge_mut = edge.as_mut();
-        if let Some(edge_layer) = edge_mut.get_layer_mut(layer) {
-            for (prop_id, prop) in props {
-                let prop = self.process_prop_value(prop);
-                let prop = validate_prop(prop).map_err(MutationError::from)?;
-                edge_layer
-                    .update_metadata(*prop_id, prop)
-                    .map_err(MutationError::from)?;
-            }
-            Ok(edge)
-        } else {
-            let layer = self.get_layer_name(layer).to_string();
-            let src = self.node(edge.as_ref().src()).as_ref().id().to_string();
-            let dst = self.node(edge.as_ref().dst()).as_ref().id().to_string();
-            Err(MutationError::InvalidEdgeLayer { layer, src, dst })
-        }
+        layer: LayerId,
+        props: Vec<(usize, Prop)>,
+    ) -> Result<EdgeWriterT<'_>, Self::Error> {
+        let (_, edge_pos) = self.storage().edges().resolve_pos(eid);
+        let mut writer = self.storage().edge_writer(eid);
+
+        let (src, dst) = writer.get_edge(layer, edge_pos).unwrap_or_else(|| {
+            panic!("Edge with EID {eid:?} not found in layer {layer}");
+        });
+
+        writer.update_c_props(edge_pos, src, dst, layer, props);
+
+        Ok(writer)
     }
 }
 
 impl InternalPropertyAdditionOps for GraphStorage {
     type Error = MutationError;
 
-    fn internal_add_properties(
+    fn internal_add_properties<P: AsPropRef>(
         &self,
         t: EventTime,
-        props: &[(usize, Prop)],
-    ) -> Result<(), Self::Error> {
+        props: &[(usize, P)],
+    ) -> Result<GraphPropWriterT<'_>, Self::Error> {
         self.mutable()?.internal_add_properties(t, props)
     }
 
-    fn internal_add_metadata(&self, props: &[(usize, Prop)]) -> Result<(), Self::Error> {
+    fn internal_add_metadata<P: AsPropRef>(
+        &self,
+        props: &[(usize, P)],
+    ) -> Result<GraphPropWriterT<'_>, Self::Error> {
         self.mutable()?.internal_add_metadata(props)
     }
 
-    fn internal_update_metadata(&self, props: &[(usize, Prop)]) -> Result<(), Self::Error> {
+    fn internal_update_metadata(
+        &self,
+        props: &[(usize, Prop)],
+    ) -> Result<GraphPropWriterT<'_>, Self::Error> {
         self.mutable()?.internal_update_metadata(props)
     }
 
-    fn internal_add_node_metadata(
+    fn internal_add_node_metadata<P: AsPropRef>(
         &self,
         vid: VID,
-        props: &[(usize, Prop)],
-    ) -> Result<EntryMut<'_, RwLockWriteGuard<'_, NodeSlot>>, Self::Error> {
+        props: Vec<(usize, P)>,
+    ) -> Result<NodeWriterT<'_>, Self::Error> {
         self.mutable()?.internal_add_node_metadata(vid, props)
     }
 
     fn internal_update_node_metadata(
         &self,
         vid: VID,
-        props: &[(usize, Prop)],
-    ) -> Result<EntryMut<'_, RwLockWriteGuard<'_, NodeSlot>>, Self::Error> {
+        props: Vec<(usize, Prop)>,
+    ) -> Result<NodeWriterT<'_>, Self::Error> {
         self.mutable()?.internal_update_node_metadata(vid, props)
     }
 
-    fn internal_add_edge_metadata(
+    fn internal_add_edge_metadata<P: AsPropRef>(
         &self,
         eid: EID,
-        layer: usize,
-        props: &[(usize, Prop)],
-    ) -> Result<EdgeWGuard<'_>, Self::Error> {
+        layer: LayerId,
+        props: Vec<(usize, P)>,
+    ) -> Result<EdgeWriterT<'_>, Self::Error> {
         self.mutable()?
             .internal_add_edge_metadata(eid, layer, props)
     }
@@ -222,9 +223,9 @@ impl InternalPropertyAdditionOps for GraphStorage {
     fn internal_update_edge_metadata(
         &self,
         eid: EID,
-        layer: usize,
-        props: &[(usize, Prop)],
-    ) -> Result<EdgeWGuard<'_>, Self::Error> {
+        layer: LayerId,
+        props: Vec<(usize, Prop)>,
+    ) -> Result<EdgeWriterT<'_>, Self::Error> {
         self.mutable()?
             .internal_update_edge_metadata(eid, layer, props)
     }
@@ -239,30 +240,36 @@ where
     type Error = <G::Base as InternalPropertyAdditionOps>::Error;
 
     #[inline]
-    fn internal_add_properties(
+    fn internal_add_properties<P: AsPropRef>(
         &self,
         t: EventTime,
-        props: &[(usize, Prop)],
-    ) -> Result<(), Self::Error> {
+        props: &[(usize, P)],
+    ) -> Result<GraphPropWriterT<'_>, Self::Error> {
         self.base().internal_add_properties(t, props)
     }
 
     #[inline]
-    fn internal_add_metadata(&self, props: &[(usize, Prop)]) -> Result<(), Self::Error> {
+    fn internal_add_metadata<P: AsPropRef>(
+        &self,
+        props: &[(usize, P)],
+    ) -> Result<GraphPropWriterT<'_>, Self::Error> {
         self.base().internal_add_metadata(props)
     }
 
     #[inline]
-    fn internal_update_metadata(&self, props: &[(usize, Prop)]) -> Result<(), Self::Error> {
+    fn internal_update_metadata(
+        &self,
+        props: &[(usize, Prop)],
+    ) -> Result<GraphPropWriterT<'_>, Self::Error> {
         self.base().internal_update_metadata(props)
     }
 
     #[inline]
-    fn internal_add_node_metadata(
+    fn internal_add_node_metadata<P: AsPropRef>(
         &self,
         vid: VID,
-        props: &[(usize, Prop)],
-    ) -> Result<EntryMut<'_, RwLockWriteGuard<'_, NodeSlot>>, Self::Error> {
+        props: Vec<(usize, P)>,
+    ) -> Result<NodeWriterT<'_>, Self::Error> {
         self.base().internal_add_node_metadata(vid, props)
     }
 
@@ -270,18 +277,18 @@ where
     fn internal_update_node_metadata(
         &self,
         vid: VID,
-        props: &[(usize, Prop)],
-    ) -> Result<EntryMut<'_, RwLockWriteGuard<'_, NodeSlot>>, Self::Error> {
+        props: Vec<(usize, Prop)>,
+    ) -> Result<NodeWriterT<'_>, Self::Error> {
         self.base().internal_update_node_metadata(vid, props)
     }
 
     #[inline]
-    fn internal_add_edge_metadata(
+    fn internal_add_edge_metadata<P: AsPropRef>(
         &self,
         eid: EID,
-        layer: usize,
-        props: &[(usize, Prop)],
-    ) -> Result<EdgeWGuard<'_>, Self::Error> {
+        layer: LayerId,
+        props: Vec<(usize, P)>,
+    ) -> Result<EdgeWriterT<'_>, Self::Error> {
         self.base().internal_add_edge_metadata(eid, layer, props)
     }
 
@@ -289,9 +296,9 @@ where
     fn internal_update_edge_metadata(
         &self,
         eid: EID,
-        layer: usize,
-        props: &[(usize, Prop)],
-    ) -> Result<EdgeWGuard<'_>, Self::Error> {
+        layer: LayerId,
+        props: Vec<(usize, Prop)>,
+    ) -> Result<EdgeWriterT<'_>, Self::Error> {
         self.base().internal_update_edge_metadata(eid, layer, props)
     }
 }
diff --git a/raphtory-storage/src/recovery_ops.rs b/raphtory-storage/src/recovery_ops.rs
new file mode 100644
index 0000000000..1f94473a9a
--- /dev/null
+++ b/raphtory-storage/src/recovery_ops.rs
@@ -0,0 +1,58 @@
+use storage::{
+    persist::control_file::{ControlFileOps, DBState, LAST_CHECKPOINT_INIT},
+    wal::{GraphWalOps, WalOps},
+};
+
+use crate::{
+    durability_ops::DurabilityOps,
+    mutation::{addition_ops::InternalAdditionOps, MutationError},
+};
+
+pub trait RecoveryOps: DurabilityOps + InternalAdditionOps<Error = MutationError> {
+    /// Recover from a crash if needed by replaying updates from the WAL.
+    fn run_recovery(&self) -> Result<(), MutationError> {
+        let wal = self.wal()?;
+        let control_file = self.control_file()?;
+
+        match control_file.db_state() {
+            DBState::Shutdown => {
+                let checkpoint_lsn = control_file.last_checkpoint();
+                let end_of_wal_lsn = wal.read_shutdown_checkpoint(checkpoint_lsn)?;
+
+                // LSN after the shutdown checkpoint points to the end of WAL stream.
+                // Set this as the next LSN for future writes.
+                wal.set_position(end_of_wal_lsn)?;
+            }
+            DBState::Running | DBState::CrashRecovery => {
+                let checkpoint_lsn = control_file.last_checkpoint();
+
+                let redo_lsn = if checkpoint_lsn == LAST_CHECKPOINT_INIT {
+                    // No successful checkpoint has been written yet,
+                    // replay from the start of the WAL stream.
+                    0
+                } else {
+                    wal.read_checkpoint(checkpoint_lsn)?
+                };
+
+                // Set db state to indicate that recovery is in progress.
+                control_file.set_db_state(DBState::CrashRecovery);
+                control_file.save()?;
+
+                let mut write_locked_graph = self.write_lock()?;
+                let end_of_wal_lsn = wal.replay_to_graph(&mut write_locked_graph, redo_lsn)?;
+
+                // Set the next LSN for future writes to the end of the WAL stream.
+                wal.set_position(end_of_wal_lsn)?;
+            }
+            DBState::NotSupported => {
+                // Recovery is not supported, skip.
+            }
+        }
+
+        // Always set db state to Running after recovery completes.
+        control_file.set_db_state(DBState::Running);
+        control_file.save()?;
+
+        Ok(())
+    }
+}
diff --git a/raphtory/Cargo.toml b/raphtory/Cargo.toml
index 024b2cfddc..3f54ff24ed 100644
--- a/raphtory/Cargo.toml
+++ b/raphtory/Cargo.toml
@@ -15,10 +15,11 @@ homepage.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-raphtory-api.workspace = true
-raphtory-core.workspace = true
-raphtory-storage.workspace = true
-pometry-storage.workspace = true
+raphtory-api.workspace = true                                #{ path = "../raphtory-api", version = "0.15.1" }
+raphtory-core.workspace = true                               # = { path = "../raphtory-core", version = "0.15.1" }
+raphtory-storage.workspace = true                            # = { path = "../raphtory-storage", version = "0.15.1" }
+db4-graph.workspace = true
+storage.workspace = true
 iter-enum = { workspace = true, features = ["rayon"] }
 hashbrown = { workspace = true }
 chrono = { workspace = true }
@@ -50,6 +51,15 @@ roaring = { workspace = true }
 strsim = { workspace = true }
 walkdir = { workspace = true }
 uuid = { workspace = true }
+parquet = { workspace = true }
+arrow-json = { workspace = true }
+arrow-csv = { workspace = true }
+arrow = { workspace = true, features = ["chrono-tz"] }
+arrow-array.workspace = true
+arrow-schema.workspace = true
+arrow-select.workspace = true
+serde_arrow.workspace = true
+disjoint-sets = { workspace = true }
 datafusion-physical-expr-common = { workspace = true }
 datafusion-physical-expr = { workspace = true }
 datafusion-physical-plan = { workspace = true }
@@ -70,19 +80,6 @@ memmap2 = { workspace = true, optional = true }
 prost = { workspace = true, optional = true }
 prost-types = { workspace = true, optional = true }
 
-# arrow otional dependencies
-parquet = { workspace = true }
-arrow-json = { workspace = true, optional = true }
-arrow-csv = { workspace = true, optional = true}
-arrow-array = { workspace = true, features = ["chrono-tz"] }
-arrow-schema = { workspace = true }
-arrow-ipc = {workspace = true}
-arrow-buffer = {workspace = true}
-arrow-select = { workspace = true }
-arrow-data ={ workspace = true }
-serde_arrow = {workspace = true, features = ["arrow-56"] }
-arrow = { workspace = true, features = ["chrono-tz"] }
-
 # search optional dependencies
 tantivy = { workspace = true, optional = true }
 
@@ -94,8 +91,8 @@ bincode = { workspace = true, optional = true }
 minijinja = { workspace = true, optional = true }
 minijinja-contrib = { workspace = true, optional = true }
 heed = { workspace = true, optional = true }
-moka = { workspace = true, optional = true }
-lancedb = {workspace = true, optional = true }
+moka = { workspace = true, optional = true, features = ["future"] }
+lancedb = { workspace = true, optional = true }
 axum = "0.8.4" # TODO put this in the proper place and make optional
 
 # python binding optional dependencies
@@ -105,7 +102,7 @@ num = { workspace = true, optional = true }
 display-error-chain = { workspace = true, optional = true }
 tempfile = { workspace = true, optional = true }
 pyo3-arrow = { workspace = true, optional = true }
-
+pythonize = { workspace = true, optional = true }
 
 # test utils
 proptest = { workspace = true, optional = true }
@@ -119,15 +116,19 @@ tokio = { workspace = true }                             # for vector testing
 dotenv = { workspace = true }                            # for vector testing
 streaming-stats = { workspace = true }
 indoc = { workspace = true }
-raphtory = { path = ".", features = ["test-utils"] } # enable test-utils for integration tests (version is not set to make cargo publish work)
-quickcheck = { workspace = true }
-quickcheck_macros = { workspace = true }
+raphtory = { workspace = true, features = ["test-utils"] } # enable test-utils for integration tests
+
+[target.'cfg(target_os = "macos")'.dependencies]
+tikv-jemallocator = "0.6.1"
 
 [build-dependencies]
 prost-build = { workspace = true, optional = true }
 
 [features]
 default = []
+
+# enables progress bars
+progress = ["dep:kdam"]
 # Enables the graph loader io module
 io = [
     "dep:neo4rs",
@@ -136,7 +137,9 @@ io = [
     "dep:csv",
     "dep:reqwest",
     "dep:tokio",
-    "proto",
+    "dep:tempfile",
+    "dep:zip",
+    "dep:kdam",
 ]
 
 # search
@@ -160,44 +163,29 @@ vectors = [
 # Enables generating the pyo3 python bindings
 python = [
     "io",
-    "arrow",
-    "search",
+    "progress",
     "vectors",
-    "proto",
     "dep:pyo3",
     "dep:numpy",
     "dep:num",
     "dep:display-error-chain",
-    "pyo3-arrow",
+    "dep:pyo3-arrow",
+    "dep:pythonize",
     "raphtory-api/python",
     "raphtory-core/python",
     "kdam/notebook",
 ]
-# storage
-storage = [
-    "arrow",
-    "raphtory-api/storage",
-    "raphtory-storage/storage",
-    "dep:memmap2",
-    "dep:tempfile",
-]
-arrow = [
-    "raphtory-api/arrow",
-    "raphtory-core/arrow",
-    "dep:arrow-json",
-    "dep:arrow-csv",
-]
+
 
 proto = [
     "dep:prost",
     "dep:prost-types",
-    "dep:zip",
     "dep:prost-build",
     "dep:memmap2",
-    "arrow",
     "io",
 ]
 
 test-utils = [
-    "dep:proptest", "dep:proptest-derive", "arrow"
+    "dep:proptest",
+    "dep:proptest-derive"
 ]
diff --git a/raphtory/build.rs b/raphtory/build.rs
index be1eda9fde..f424e39b19 100644
--- a/raphtory/build.rs
+++ b/raphtory/build.rs
@@ -3,10 +3,19 @@ use std::io::Result;
 fn main() -> Result<()> {
     prost_build::compile_protos(&["src/serialise/graph.proto"], &["src/serialise"])?;
     println!("cargo::rerun-if-changed=src/serialise/graph.proto");
+
+    println!("cargo::rustc-check-cfg=cfg(has_debug_symbols)");
+    if let Ok("true" | "1" | "2") = std::env::var("DEBUG").as_deref() {
+        println!("cargo::rustc-cfg=has_debug_symbols");
+    }
     Ok(())
 }
 
 #[cfg(not(feature = "proto"))]
 fn main() -> Result<()> {
+    println!("cargo::rustc-check-cfg=cfg(has_debug_symbols)");
+    if let Ok("true" | "1" | "2") = std::env::var("DEBUG").as_deref() {
+        println!("cargo::rustc-cfg=has_debug_symbols");
+    }
     Ok(())
 }
diff --git a/raphtory/examples/eth_loader.rs b/raphtory/examples/eth_loader.rs
new file mode 100644
index 0000000000..9e2fdd2afd
--- /dev/null
+++ b/raphtory/examples/eth_loader.rs
@@ -0,0 +1,51 @@
+#[cfg(feature = "io")]
+use raphtory::io::{
+    arrow::df_loaders::edges::ColumnNames, parquet_loaders::load_edges_from_parquet,
+};
+use raphtory::{errors::GraphError, prelude::*};
+use std::path::{Path, PathBuf};
+
+/// Load ETH data from Parquet files into a Raphtory Graph.
+#[cfg(feature = "io")]
+fn load_eth_graph(parquet_path: &Path, graph: &Graph) -> Result<(), GraphError> {
+    // ── Static Nodes ──────────────────────────────────────────────────────
+
+    load_edges_from_parquet(
+        graph,
+        parquet_path,
+        ColumnNames::new("block_timestamp", None, "from_address", "to_address", None),
+        true,
+        &["transaction_index", "value", "gas", "gas_price", "hash"],
+        &[],
+        None,
+        Some("ETH"),
+        None,
+        None,
+    )?;
+    graph.flush()?;
+    println!("  ✓ ETH edges");
+
+    println!(
+        "\n✅ Graph loaded: {} nodes, {} edges",
+        graph.count_nodes(),
+        graph.count_edges()
+    );
+    Ok(())
+}
+
+#[cfg(feature = "io")]
+fn main() {
+    let parquet_path = std::env::args()
+        .nth(1)
+        .map(|dir| PathBuf::from(dir))
+        .unwrap_or_else(|| panic!("Usage: snb_loader <data_dir>"));
+    let graph_path = std::env::args()
+        .nth(2)
+        .map(|graph| PathBuf::from(graph))
+        .unwrap_or_else(|| parquet_path.join("..").join("graph"));
+    let graph = Graph::new_at_path(&graph_path).unwrap();
+    load_eth_graph(&parquet_path, &graph).unwrap()
+}
+
+#[cfg(not(feature = "io"))]
+fn main() {}
diff --git a/raphtory/examples/snb_loader.rs b/raphtory/examples/snb_loader.rs
new file mode 100644
index 0000000000..b8bfb73fa8
--- /dev/null
+++ b/raphtory/examples/snb_loader.rs
@@ -0,0 +1,579 @@
+#[cfg(feature = "io")]
+use raphtory::io::{
+    arrow::df_loaders::edges::ColumnNames,
+    parquet_loaders::{load_edges_from_parquet, load_nodes_from_parquet},
+};
+use raphtory::{errors::GraphError, prelude::*};
+use std::path::{Path, PathBuf};
+
+/// Construct the path to a named Parquet file inside `parquet_dir`.
+fn pq(parquet_dir: &Path, name: &str) -> PathBuf {
+    parquet_dir.join(format!("{}.parquet", name))
+}
+
+#[cfg(target_os = "macos")]
+use tikv_jemallocator::Jemalloc;
+
+#[cfg(target_os = "macos")]
+#[global_allocator]
+static GLOBAL: Jemalloc = Jemalloc;
+
+/// Load SNB data from Parquet files into a Raphtory Graph.
+#[cfg(feature = "io")]
+fn load_snb_graph(parquet_dir: &Path, graph: &Graph) -> Result<(), GraphError> {
+    // ── Static Nodes ──────────────────────────────────────────────────────
+
+    // println!("Loading Places...");
+    // load_nodes_from_parquet(
+    //     graph,
+    //     &pq(parquet_dir, "place"),
+    //     "_time",
+    //     None,
+    //     "_node_id",
+    //     None,
+    //     Some("type"),
+    //     &["name", "url", "id"],
+    //     &[],
+    //     None,
+    //     None,
+    //     true,
+    //     None,
+    // )?;
+    // println!("  ✓ places");
+
+    // let fp = pq(parquet_dir, "place_IS_PART_OF_place");
+    // if fp.exists() {
+    //     load_edges_from_parquet(
+    //         graph,
+    //         &fp,
+    //         ColumnNames::new("_time", None, "START_ID", "END_ID", None),
+    //         true,
+    //         &[],
+    //         &[],
+    //         None,
+    //         Some("IS_PART_OF"),
+    //         None,
+    //         None,
+    //     )?;
+    //     graph.flush()?;
+    //     println!("  ✓ IS_PART_OF edges");
+    // }
+
+    // println!("Loading Organisations...");
+    // load_nodes_from_parquet(
+    //     graph,
+    //     &pq(parquet_dir, "organisation"),
+    //     "_time",
+    //     None,
+    //     "_node_id",
+    //     None,
+    //     Some("type"),
+    //     &["name", "url", "id"],
+    //     &[],
+    //     None,
+    //     None,
+    //     true,
+    //     None,
+    // )?;
+    // println!("  ✓ organisations");
+
+    // load_edges_from_parquet(
+    //     graph,
+    //     &pq(parquet_dir, "organisation_IS_LOCATED_IN_place"),
+    //     ColumnNames::new("_time", None, "START_ID", "END_ID", None),
+    //     true,
+    //     &[],
+    //     &[],
+    //     None,
+    //     Some("IS_LOCATED_IN"),
+    //     None,
+    //     None,
+    // )?;
+    // graph.flush()?;
+    // println!("  ✓ Organisation IS_LOCATED_IN edges");
+
+    // println!("Loading Tags...");
+    // load_nodes_from_parquet(
+    //     graph,
+    //     &pq(parquet_dir, "tag"),
+    //     "_time",
+    //     None,
+    //     "_node_id",
+    //     Some("Tag"),
+    //     None,
+    //     &["name", "url", "id"],
+    //     &[],
+    //     None,
+    //     None,
+    //     true,
+    //     None,
+    // )?;
+    // println!("  ✓ tags");
+
+    // let fp = pq(parquet_dir, "tagclass");
+    // if fp.exists() {
+    //     println!("Loading TagClasses...");
+    //     load_nodes_from_parquet(
+    //         graph,
+    //         &fp,
+    //         "_time",
+    //         None,
+    //         "_node_id",
+    //         Some("TagClass"),
+    //         None,
+    //         &["name", "url", "id"],
+    //         &[],
+    //         None,
+    //         None,
+    //         true,
+    //         None,
+    //     )?;
+    //     println!("  ✓ tag classes");
+    // }
+
+    // let fp = pq(parquet_dir, "tag_HAS_TYPE_tagclass");
+    // if fp.exists() {
+    //     load_edges_from_parquet(
+    //         graph,
+    //         &fp,
+    //         ColumnNames::new("_time", None, "START_ID", "END_ID", None),
+    //         true,
+    //         &[],
+    //         &[],
+    //         None,
+    //         Some("HAS_TYPE"),
+    //         None,
+    //         None,
+    //     )?;
+    //     graph.flush()?;
+    //     println!("  ✓ HAS_TYPE edges");
+    // }
+
+    // let fp = pq(parquet_dir, "tagclass_IS_SUBCLASS_OF_tagclass");
+    // if fp.exists() {
+    //     load_edges_from_parquet(
+    //         graph,
+    //         &fp,
+    //         ColumnNames::new("_time", None, "START_ID", "END_ID", None),
+    //         true,
+    //         &[],
+    //         &[],
+    //         None,
+    //         Some("IS_SUBCLASS_OF"),
+    //         None,
+    //         None,
+    //     )?;
+    //     graph.flush()?;
+    //     println!("  ✓ IS_SUBCLASS_OF edges");
+    // }
+
+    // // ── Dynamic Nodes ─────────────────────────────────────────────────────
+
+    // println!("Loading Persons...");
+    // load_nodes_from_parquet(
+    //     graph,
+    //     &pq(parquet_dir, "person"),
+    //     "creationDate",
+    //     None,
+    //     "_node_id",
+    //     Some("Person"),
+    //     None,
+    //     &[
+    //         "firstName",
+    //         "lastName",
+    //         "gender",
+    //         "birthday",
+    //         "locationIP",
+    //         "browserUsed",
+    //         "language",
+    //         "email",
+    //         "id",
+    //         "creationDate",
+    //     ],
+    //     &[],
+    //     None,
+    //     None,
+    //     true,
+    //     None,
+    // )?;
+    // println!("  ✓ persons");
+
+    // load_edges_from_parquet(
+    //     graph,
+    //     &pq(parquet_dir, "person_IS_LOCATED_IN_place"),
+    //     ColumnNames::new("_time", None, "START_ID", "END_ID", None),
+    //     true,
+    //     &[],
+    //     &[],
+    //     None,
+    //     Some("IS_LOCATED_IN"),
+    //     None,
+    //     None,
+    // )?;
+    // graph.flush()?;
+
+    // println!("Loading Forums...");
+    // load_nodes_from_parquet(
+    //     graph,
+    //     &pq(parquet_dir, "forum"),
+    //     "creationDate",
+    //     None,
+    //     "_node_id",
+    //     Some("Forum"),
+    //     None,
+    //     &["title", "id", "creationDate"],
+    //     &[],
+    //     None,
+    //     None,
+    //     true,
+    //     None,
+    // )?;
+    // println!("  ✓ forums");
+
+    // load_edges_from_parquet(
+    //     graph,
+    //     &pq(parquet_dir, "forum_HAS_MODERATOR_person"),
+    //     ColumnNames::new("_time", None, "START_ID", "END_ID", None),
+    //     true,
+    //     &[],
+    //     &[],
+    //     None,
+    //     Some("HAS_MODERATOR"),
+    //     None,
+    //     None,
+    // )?;
+    // graph.flush()?;
+
+    // println!("Loading Posts...");
+    // load_nodes_from_parquet(
+    //     graph,
+    //     &pq(parquet_dir, "post"),
+    //     "creationDate",
+    //     None,
+    //     "_node_id",
+    //     Some("Post"),
+    //     None,
+    //     &[
+    //         "imageFile",
+    //         "locationIP",
+    //         "browserUsed",
+    //         "language",
+    //         "content",
+    //         "length",
+    //         "id",
+    //         "creationDate",
+    //     ],
+    //     &[],
+    //     None,
+    //     None,
+    //     true,
+    //     None,
+    // )?;
+    // println!("  ✓ posts");
+
+    // load_edges_from_parquet(
+    //     graph,
+    //     &pq(parquet_dir, "post_HAS_CREATOR_person"),
+    //     ColumnNames::new("_time", None, "START_ID", "END_ID", None),
+    //     true,
+    //     &[],
+    //     &[],
+    //     None,
+    //     Some("HAS_CREATOR"),
+    //     None,
+    //     None,
+    // )?;
+    // graph.flush()?;
+
+    // load_edges_from_parquet(
+    //     graph,
+    //     &pq(parquet_dir, "post_IS_LOCATED_IN_place"),
+    //     ColumnNames::new("_time", None, "START_ID", "END_ID", None),
+    //     true,
+    //     &[],
+    //     &[],
+    //     None,
+    //     Some("IS_LOCATED_IN"),
+    //     None,
+    //     None,
+    // )?;
+    // graph.flush()?;
+
+    // load_edges_from_parquet(
+    //     graph,
+    //     &pq(parquet_dir, "forum_CONTAINER_OF_post"),
+    //     ColumnNames::new("_time", None, "START_ID", "END_ID", None),
+    //     true,
+    //     &[],
+    //     &[],
+    //     None,
+    //     Some("CONTAINER_OF"),
+    //     None,
+    //     None,
+    // )?;
+    // graph.flush()?;
+
+    println!("Loading Comments...");
+    load_nodes_from_parquet(
+        graph,
+        &pq(parquet_dir, "comment"),
+        "creationDate",
+        None,
+        "_node_id",
+        Some("Comment"),
+        None,
+        &[
+            "locationIP",
+            "browserUsed",
+            "content",
+            "length",
+            "id",
+            "creationDate",
+        ],
+        &[],
+        None,
+        None,
+        None,
+        None,
+        true,
+        None,
+    )?;
+    println!("  ✓ comments");
+    // graph.flush()?;
+
+    load_edges_from_parquet(
+        graph,
+        &pq(parquet_dir, "comment_HAS_CREATOR_person"),
+        ColumnNames::new("_time", None, "START_ID", "END_ID", None),
+        true,
+        &[],
+        &[],
+        None,
+        Some("HAS_CREATOR"),
+        None,
+        None,
+    )?;
+    // graph.flush()?;
+
+    load_edges_from_parquet(
+        graph,
+        &pq(parquet_dir, "comment_IS_LOCATED_IN_place"),
+        ColumnNames::new("_time", None, "START_ID", "END_ID", None),
+        true,
+        &[],
+        &[],
+        None,
+        Some("IS_LOCATED_IN"),
+        None,
+        None,
+    )?;
+    // graph.flush()?;
+
+    load_edges_from_parquet(
+        graph,
+        &pq(parquet_dir, "comment_REPLY_OF_post"),
+        ColumnNames::new("_time", None, "START_ID", "END_ID", None),
+        true,
+        &[],
+        &[],
+        None,
+        Some("REPLY_OF"),
+        None,
+        None,
+    )?;
+
+    load_edges_from_parquet(
+        graph,
+        &pq(parquet_dir, "comment_REPLY_OF_comment"),
+        ColumnNames::new("_time", None, "START_ID", "END_ID", None),
+        true,
+        &[],
+        &[],
+        None,
+        Some("REPLY_OF"),
+        None,
+        None,
+    )?;
+    // graph.flush()?;
+
+    // ── Edge-only relationships ───────────────────────────────────────────
+
+    println!("Loading KNOWS edges...");
+    load_edges_from_parquet(
+        graph,
+        &pq(parquet_dir, "person_KNOWS_person"),
+        ColumnNames::new("creationDate", None, "START_ID", "END_ID", None),
+        true,
+        &["creationDate"],
+        &[],
+        None,
+        Some("KNOWS"),
+        None,
+        None,
+    )?;
+    graph.flush()?;
+    println!("  ✓ KNOWS edges");
+
+    println!("Loading LIKES edges...");
+    load_edges_from_parquet(
+        graph,
+        &pq(parquet_dir, "person_LIKES_post"),
+        ColumnNames::new("creationDate", None, "START_ID", "END_ID", None),
+        true,
+        &["creationDate"],
+        &[],
+        None,
+        Some("LIKES"),
+        None,
+        None,
+    )?;
+    graph.flush()?;
+    println!("  ✓ LIKES (Post) edges");
+
+    load_edges_from_parquet(
+        graph,
+        &pq(parquet_dir, "person_LIKES_comment"),
+        ColumnNames::new("creationDate", None, "START_ID", "END_ID", None),
+        true,
+        &["creationDate"],
+        &[],
+        None,
+        Some("LIKES"),
+        None,
+        None,
+    )?;
+    graph.flush()?;
+    println!("  ✓ LIKES (Comment) edges");
+
+    println!("Loading HAS_MEMBER edges...");
+    load_edges_from_parquet(
+        graph,
+        &pq(parquet_dir, "forum_HAS_MEMBER_person"),
+        ColumnNames::new("joinDate", None, "START_ID", "END_ID", None),
+        true,
+        &["joinDate"],
+        &[],
+        None,
+        Some("HAS_MEMBER"),
+        None,
+        None,
+    )?;
+    graph.flush()?;
+    println!("  ✓ HAS_MEMBER edges");
+
+    println!("Loading STUDY_AT edges...");
+    load_edges_from_parquet(
+        graph,
+        &pq(parquet_dir, "person_STUDY_AT_organisation"),
+        ColumnNames::new("_time", None, "START_ID", "END_ID", None),
+        true,
+        &["classYear"],
+        &[],
+        None,
+        Some("STUDY_AT"),
+        None,
+        None,
+    )?;
+    graph.flush()?;
+    println!("  ✓ STUDY_AT edges");
+
+    println!("Loading WORK_AT edges...");
+    load_edges_from_parquet(
+        graph,
+        &pq(parquet_dir, "person_WORK_AT_organisation"),
+        ColumnNames::new("_time", None, "START_ID", "END_ID", None),
+        true,
+        &["workFrom"],
+        &[],
+        None,
+        Some("WORK_AT"),
+        None,
+        None,
+    )?;
+    graph.flush()?;
+    println!("  ✓ WORK_AT edges");
+
+    println!("Loading HAS_TAG edges...");
+    load_edges_from_parquet(
+        graph,
+        &pq(parquet_dir, "post_HAS_TAG_tag"),
+        ColumnNames::new("_time", None, "START_ID", "END_ID", None),
+        true,
+        &[],
+        &[],
+        None,
+        Some("HAS_TAG"),
+        None,
+        None,
+    )?;
+    graph.flush()?;
+
+    load_edges_from_parquet(
+        graph,
+        &pq(parquet_dir, "comment_HAS_TAG_tag"),
+        ColumnNames::new("_time", None, "START_ID", "END_ID", None),
+        true,
+        &[],
+        &[],
+        None,
+        Some("HAS_TAG"),
+        None,
+        None,
+    )?;
+    graph.flush()?;
+
+    load_edges_from_parquet(
+        graph,
+        &pq(parquet_dir, "forum_HAS_TAG_tag"),
+        ColumnNames::new("_time", None, "START_ID", "END_ID", None),
+        true,
+        &[],
+        &[],
+        None,
+        Some("HAS_TAG"),
+        None,
+        None,
+    )?;
+    graph.flush()?;
+    println!("  ✓ HAS_TAG edges");
+
+    println!("Loading HAS_INTEREST edges...");
+    load_edges_from_parquet(
+        graph,
+        &pq(parquet_dir, "person_HAS_INTEREST_tag"),
+        ColumnNames::new("_time", None, "START_ID", "END_ID", None),
+        true,
+        &[],
+        &[],
+        None,
+        Some("HAS_INTEREST"),
+        None,
+        None,
+    )?;
+    graph.flush()?;
+    println!("  ✓ HAS_INTEREST edges");
+
+    println!(
+        "\n✅ Graph loaded: {} nodes, {} edges",
+        graph.count_nodes(),
+        graph.count_edges()
+    );
+    Ok(())
+}
+
+#[cfg(feature = "io")]
+fn main() {
+    let parquet_dir = std::env::args()
+        .nth(1)
+        .map(|dir| PathBuf::from(dir))
+        .unwrap_or_else(|| panic!("Usage: snb_loader <data_dir>"));
+    let graph_path = std::env::args()
+        .nth(2)
+        .map(|graph| PathBuf::from(graph))
+        .unwrap_or_else(|| parquet_dir.join("..").join("graph"));
+    let graph = Graph::new_at_path(&graph_path).unwrap();
+    load_snb_graph(&parquet_dir, &graph).unwrap()
+}
+
+#[cfg(not(feature = "io"))]
+fn main() {}
diff --git a/raphtory/src/algorithms/centrality/betweenness.rs b/raphtory/src/algorithms/centrality/betweenness.rs
index 31e762420c..cea78970f5 100644
--- a/raphtory/src/algorithms/centrality/betweenness.rs
+++ b/raphtory/src/algorithms/centrality/betweenness.rs
@@ -3,7 +3,7 @@ use serde::{Deserialize, Serialize};
 use crate::{
     core::entities::VID,
     db::{
-        api::state::{GenericNodeState, TypedNodeState},
+        api::state::{GenericNodeState, Index, TypedNodeState},
         graph::node::NodeView,
     },
     prelude::{GraphViewOps, NodeViewOps},
@@ -31,8 +31,9 @@ pub fn betweenness_centrality<'graph, G: GraphViewOps<'graph>>(
     k: Option<usize>,
     normalized: bool,
 ) -> TypedNodeState<'graph, BetweennessCentrality, G> {
+    let index = Index::for_graph(g);
     // Initialize a hashmap to store betweenness centrality values.
-    let mut betweenness: Vec<f64> = vec![0.0; g.unfiltered_num_nodes()];
+    let mut betweenness: Vec<f64> = vec![0.0; g.count_nodes()];
 
     // Get the nodes and the total number of nodes in the graph.
     let nodes = g.nodes();
@@ -41,49 +42,47 @@ pub fn betweenness_centrality<'graph, G: GraphViewOps<'graph>>(
 
     // Main loop over each node to compute betweenness centrality.
     for node in nodes.iter().take(k_sample) {
-        let mut stack = Vec::new();
-        let mut predecessors: HashMap<usize, Vec<usize>> = HashMap::new();
-        let mut sigma: HashMap<usize, f64> = HashMap::new();
-        let mut dist: HashMap<usize, i64> = HashMap::new();
+        let mut stack: Vec<VID> = Vec::new();
+        let mut predecessors: HashMap<VID, Vec<VID>> = HashMap::new();
+        let mut sigma: HashMap<VID, f64> = HashMap::new();
+        let mut dist: HashMap<VID, i64> = HashMap::new();
         let mut queue = VecDeque::new();
 
         // Initialize distance and sigma values for each node.
         for node in nodes.iter() {
-            dist.insert(node.node.0, -1);
-            sigma.insert(node.node.0, 0.0);
+            dist.insert(node.node, -1);
+            sigma.insert(node.node, 0.0);
         }
-        dist.insert(node.node.0, 0);
-        sigma.insert(node.node.0, 1.0);
-        queue.push_back(node.node.0);
+        dist.insert(node.node, 0);
+        sigma.insert(node.node, 1.0);
+        queue.push_back(node.node);
 
         // BFS loop to find shortest paths.
         while let Some(current_node_id) = queue.pop_front() {
             stack.push(current_node_id);
-            for neighbor in
-                NodeView::new_internal(g.clone(), VID::from(current_node_id)).out_neighbours()
-            {
+            for neighbor in NodeView::new_internal(g.clone(), current_node_id).out_neighbours() {
                 // Path discovery
-                if dist[&neighbor.node.0] < 0 {
-                    queue.push_back(neighbor.node.0);
-                    dist.insert(neighbor.node.0, dist[&current_node_id] + 1);
+                if dist[&neighbor.node] < 0 {
+                    queue.push_back(neighbor.node);
+                    dist.insert(neighbor.node, dist[&current_node_id] + 1);
                 }
                 // Path counting
-                if dist[&neighbor.node.0] == dist[&current_node_id] + 1 {
+                if dist[&neighbor.node] == dist[&current_node_id] + 1 {
                     sigma.insert(
-                        neighbor.node.0,
-                        sigma[&neighbor.node.0] + sigma[&current_node_id],
+                        neighbor.node,
+                        sigma[&neighbor.node] + sigma[&current_node_id],
                     );
                     predecessors
-                        .entry(neighbor.node.0)
+                        .entry(neighbor.node)
                         .or_default()
                         .push(current_node_id);
                 }
             }
         }
 
-        let mut delta: HashMap<usize, f64> = HashMap::new();
+        let mut delta: HashMap<VID, f64> = HashMap::new();
         for node in nodes.iter() {
-            delta.insert(node.node.0, 0.0);
+            delta.insert(node.node, 0.0);
         }
 
         // Accumulation
@@ -93,8 +92,9 @@ pub fn betweenness_centrality<'graph, G: GraphViewOps<'graph>>(
                 let new_delta_v = delta[v] + coeff;
                 delta.insert(*v, new_delta_v);
             }
-            if w != node.node.0 {
-                betweenness[w] += delta[&w];
+            if w != node.node {
+                let pos = index.index(&w).unwrap();
+                betweenness[pos] += delta[&w];
             }
         }
     }
@@ -103,7 +103,8 @@ pub fn betweenness_centrality<'graph, G: GraphViewOps<'graph>>(
     if normalized {
         let factor = 1.0 / ((n as f64 - 1.0) * (n as f64 - 2.0));
         for node in nodes.iter() {
-            betweenness[node.node.index()] *= factor;
+            let pos = index.index(&node.node).unwrap();
+            betweenness[pos] *= factor;
         }
     }
 
diff --git a/raphtory/src/algorithms/centrality/degree_centrality.rs b/raphtory/src/algorithms/centrality/degree_centrality.rs
index a1595b80f2..afcb8aad25 100644
--- a/raphtory/src/algorithms/centrality/degree_centrality.rs
+++ b/raphtory/src/algorithms/centrality/degree_centrality.rs
@@ -8,12 +8,18 @@ use crate::{
 use rayon::prelude::*;
 use serde::{Deserialize, Serialize};
 
-#[derive(Clone, PartialEq, Serialize, Deserialize, Debug)]
+#[derive(Copy, Clone, PartialEq, Serialize, Deserialize, Debug)]
 pub struct CentralityScore {
     #[serde(rename = "degree_centrality")]
     pub score: f64,
 }
 
+impl PartialEq<f64> for CentralityScore {
+    fn eq(&self, other: &f64) -> bool {
+        self.score == *other
+    }
+}
+
 /// Computes the degree centrality of all nodes in the graph. The values are normalized
 /// by dividing each result with the maximum possible degree. Graphs with self-loops can have
 /// values of centrality greater than 1.
@@ -34,14 +40,31 @@ pub fn degree_centrality<G: StaticGraphViewOps>(
         Some(v) => v,
     };
 
-    let values: Vec<CentralityScore> = g
-        .nodes()
-        .degree()
-        .into_par_iter_values()
-        .map(|v| CentralityScore {
-            score: (v as f64) / max_degree as f64,
-        })
-        .collect();
-
+    let values: Vec<_> = if max_degree == 0 {
+        vec![CentralityScore { score: 0.0 }; g.count_nodes()]
+    } else {
+        g.nodes()
+            .degree()
+            .into_par_iter_values()
+            .map(|v| CentralityScore {
+                score: (v as f64) / max_degree as f64,
+            })
+            .collect()
+    };
     TypedNodeState::new(GenericNodeState::new_from_eval(g.clone(), values, None))
 }
+
+#[cfg(test)]
+mod test {
+    use crate::{algorithms::centrality::degree_centrality::degree_centrality, prelude::*};
+
+    #[test]
+    fn test_empty_edges() {
+        let g = Graph::new();
+        for i in 0..10 {
+            g.add_node(0, i, NO_PROPS, None, None).unwrap();
+        }
+        let c = degree_centrality(&g);
+        assert_eq!(c.values_to_rows(), vec![0.0; 10])
+    }
+}
diff --git a/raphtory/src/algorithms/centrality/hits.rs b/raphtory/src/algorithms/centrality/hits.rs
index 3201b191ba..bf5155132e 100644
--- a/raphtory/src/algorithms/centrality/hits.rs
+++ b/raphtory/src/algorithms/centrality/hits.rs
@@ -142,8 +142,13 @@ pub fn hits<G: StaticGraphViewOps>(
         vec![],
         vec![Job::new(step2), Job::new(step3), Job::new(step4), step5],
         None,
-        |_, _, _, local| {
-            TypedNodeState::new(GenericNodeState::new_from_eval(g.clone(), local, None))
+        |_, _, _, local, index| {
+            TypedNodeState::new(GenericNodeState::new_from_eval_with_index(
+                g.clone(),
+                local,
+                index,
+                None,
+            ))
         },
         threads,
         iter_count,
diff --git a/raphtory/src/algorithms/centrality/pagerank.rs b/raphtory/src/algorithms/centrality/pagerank.rs
index a8e2cabe1c..c8db2077a2 100644
--- a/raphtory/src/algorithms/centrality/pagerank.rs
+++ b/raphtory/src/algorithms/centrality/pagerank.rs
@@ -163,8 +163,13 @@ pub fn unweighted_page_rank<G: StaticGraphViewOps>(
         vec![Job::new(step1)],
         vec![Job::new(step2), Job::new(step3), Job::new(step4), step5],
         Some(vec![PageRankState::new(num_nodes); num_nodes]),
-        |_, _, _, local| {
-            TypedNodeState::new(GenericNodeState::new_from_eval(g.clone(), local, None))
+        |_, _, _, local, index| {
+            TypedNodeState::new(GenericNodeState::new_from_eval_with_index(
+                g.clone(),
+                local,
+                index,
+                None,
+            ))
         },
         threads,
         iter_count,
diff --git a/raphtory/src/algorithms/community_detection/label_propagation.rs b/raphtory/src/algorithms/community_detection/label_propagation.rs
index 32480ee859..558b960b20 100644
--- a/raphtory/src/algorithms/community_detection/label_propagation.rs
+++ b/raphtory/src/algorithms/community_detection/label_propagation.rs
@@ -96,8 +96,13 @@ where
         vec![Job::new(step1)],
         vec![Job::new(step2), step3],
         None,
-        |_, _, _, local| {
-            TypedNodeState::new(GenericNodeState::new_from_eval(g.clone(), local, None))
+        |_, _, _, local, index| {
+            TypedNodeState::new(GenericNodeState::new_from_eval_with_index(
+                g.clone(),
+                local,
+                index,
+                None,
+            ))
         },
         threads,
         iter_count,
diff --git a/raphtory/src/algorithms/community_detection/louvain.rs b/raphtory/src/algorithms/community_detection/louvain.rs
index 4700e6e821..0ee88dff8c 100644
--- a/raphtory/src/algorithms/community_detection/louvain.rs
+++ b/raphtory/src/algorithms/community_detection/louvain.rs
@@ -31,7 +31,7 @@ pub fn louvain<'graph, M: ModularityFunction, G: GraphViewOps<'graph>>(
     tol: Option<f64>,
 ) -> TypedNodeState<'graph, LouvainState, G> {
     let tol = tol.unwrap_or(1e-8);
-    let mut rng = rand::thread_rng();
+    let mut rng = rand::rng();
     let mut modularity_state = M::new(
         g,
         weight_prop,
diff --git a/raphtory/src/algorithms/components/connected_components.rs b/raphtory/src/algorithms/components/connected_components.rs
index e13dc3a132..2dffbc5978 100644
--- a/raphtory/src/algorithms/components/connected_components.rs
+++ b/raphtory/src/algorithms/components/connected_components.rs
@@ -1,197 +1,23 @@
 use crate::{
-    db::{
-        api::{
-            state::{GenericNodeState, TypedNodeState},
-            view::{internal::GraphView, NodeViewOps, StaticGraphViewOps},
-        },
-        graph::node::NodeView,
+    db::api::{
+        state::{GenericNodeState, Index, TypedNodeState},
+        view::{NodeViewOps, StaticGraphViewOps},
     },
     prelude::GraphViewOps,
 };
-use raphtory_api::core::entities::VID;
+use disjoint_sets::AUnionFind;
 use rayon::prelude::*;
 use serde::{Deserialize, Serialize};
-use std::{
-    fmt::{Debug, Formatter},
-    mem,
-    sync::atomic::{AtomicUsize, Ordering},
-};
+use std::fmt::Debug;
 
-#[derive(Clone, PartialEq, Serialize, Deserialize, Debug, Default, Hash, Eq)]
+#[derive(Copy, Clone, PartialEq, Serialize, Deserialize, Debug, Default, Hash, Eq)]
 pub struct ConnectedComponent {
     pub component_id: usize,
 }
 
-/// Keeps track of node assignments to weakly-connected components
-///
-/// `node_labels` tracks the assignment of nodes to labels
-/// `chunk_labels` tracks the mapping from node labels to final components
-struct ComponentState<'graph, G> {
-    chunk_labels: Vec<AtomicUsize>,
-    node_labels: Vec<AtomicUsize>,
-    next_start: AtomicUsize,
-    next_chunk: AtomicUsize,
-    graph: &'graph G,
-}
-
-impl<'graph, G> Debug for ComponentState<'graph, G> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("ComponentState")
-            .field("chunk_labels", &self.chunk_labels)
-            .field("node_labels", &self.node_labels)
-            .field("next_start", &self.next_start)
-            .finish_non_exhaustive()
-    }
-}
-
-impl<'graph, G: GraphView + 'graph> ComponentState<'graph, G> {
-    fn new(graph: &'graph G) -> Self {
-        let num_nodes = graph.unfiltered_num_nodes();
-        let chunk_labels = (0..num_nodes)
-            .map(|_| AtomicUsize::new(usize::MAX))
-            .collect();
-        let node_labels = (0..num_nodes)
-            .map(|_| AtomicUsize::new(usize::MAX))
-            .collect();
-        let next_start = AtomicUsize::new(0);
-        let next_chunk = AtomicUsize::new(0);
-        Self {
-            chunk_labels,
-            node_labels,
-            next_start,
-            next_chunk,
-            graph,
-        }
-    }
-
-    /// Link two chunks `chunk_id_1` and `chunk_id_2` such that they will be part of the same
-    /// component in the final result.
-    ///
-    /// The components always link from larger id to smaller id. If while linking, we find that
-    /// the component was already linked, we rewire that link as well (the implementation is effectively
-    /// the same as calling this function recursively)
-    fn link_chunks(&self, chunk_id_1: usize, chunk_id_2: usize) {
-        let mut src = chunk_id_1.max(chunk_id_2);
-        let mut dst = chunk_id_1.min(chunk_id_2);
-        while src != dst {
-            let old_label = self.chunk_labels[src].fetch_min(dst, Ordering::Relaxed);
-            if old_label != usize::MAX {
-                if old_label > dst {
-                    src = old_label
-                } else {
-                    src = dst;
-                    dst = old_label
-                }
-            }
-        }
-    }
-
-    /// Find the next valid starting node for a task
-    ///
-    /// This function takes care to make sure that there will never be more tasks than
-    /// unfiltered nodes in the graph!
-    fn next_start(&self) -> Option<(usize, VID)> {
-        let mut next_start = self.next_start.fetch_add(1, Ordering::Relaxed);
-        if next_start >= self.node_labels.len() {
-            return None;
-        }
-        // only increment this if we still have a potentially valid node to avoid getting too many chunks
-        let chunk_id = self.next_chunk_label();
-        let old_label = self.chunk_labels[chunk_id].fetch_min(chunk_id, Ordering::Relaxed);
-        if old_label != usize::MAX {
-            // some other thread managed to initialise our chunk (this seems theoretically possible)
-            self.link_chunks(chunk_id, old_label);
-        }
-        loop {
-            //
-            if self.node_labels[next_start]
-                .compare_exchange(usize::MAX, chunk_id, Ordering::Relaxed, Ordering::Relaxed)
-                .is_ok()
-            {
-                if self.graph.has_node(VID(next_start)) {
-                    return Some((chunk_id, VID(next_start)));
-                }
-            }
-            next_start = self.next_start.fetch_add(1, Ordering::Relaxed);
-            if next_start >= self.node_labels.len() {
-                return None;
-            }
-        }
-    }
-
-    fn next_chunk_label(&self) -> usize {
-        self.next_chunk.fetch_add(1, Ordering::Relaxed)
-    }
-
-    /// Find a new starting point and run breadth-first search
-    ///
-    /// If we find a node that was already handled by another chunk, update the label assignments
-    /// accordingly using `link_chunks`
-    fn run_chunk(&self) -> Option<()> {
-        let (chunk_id, start) = self.next_start()?;
-        let mut min_label = chunk_id;
-        let mut new_frontier = vec![start];
-        let mut frontier = vec![];
-        while !new_frontier.is_empty() {
-            mem::swap(&mut new_frontier, &mut frontier);
-            for node_id in frontier.drain(..) {
-                for neighbour in NodeView::new_internal(self.graph, node_id).neighbours() {
-                    let node_id = neighbour.node;
-                    let old_label =
-                        self.node_labels[node_id.index()].fetch_min(min_label, Ordering::Relaxed);
-                    if old_label != usize::MAX {
-                        self.link_chunks(chunk_id, old_label);
-                        min_label = min_label.min(old_label);
-                    } else {
-                        new_frontier.push(node_id);
-                    }
-                }
-            }
-        }
-        Some(())
-    }
-
-    /// Runs breadth-first search in parallel from different starting points until the graph is covered
-    ///
-    /// During the first phase, the `node_labels` contain the id of the first task that visited that node
-    /// and the `chunk_labels` maintain a mapping from task to the minimum over other tasks that also
-    /// reached a node first discovered by this task.
-    ///
-    /// In the second phase, starting from each task, we follow the relabelling map until we hit a root task (i.e., one where the label is mapped to itself)
-    /// and simplify the chunk_labels
-    ///
-    /// Finally, the simplified chunk_labels are used to update the `node_labels` for the final output.
-    fn run(self) -> Vec<usize> {
-        let num_tasks = rayon::current_num_threads();
-        (0..num_tasks)
-            .into_par_iter()
-            .for_each(|_| while self.run_chunk().is_some() {});
-        let num_chunks = self.next_chunk.load(Ordering::Relaxed);
-        self.chunk_labels[0..num_chunks]
-            .par_iter()
-            .enumerate()
-            .for_each(|(chunk_id, label)| {
-                let mut component_id = label.load(Ordering::Relaxed);
-                let mut current_chunk = chunk_id;
-                while component_id != current_chunk {
-                    current_chunk = component_id;
-                    component_id = self.chunk_labels[current_chunk].load(Ordering::Relaxed);
-                }
-                if component_id != chunk_id {
-                    self.chunk_labels[chunk_id].fetch_min(component_id, Ordering::Relaxed);
-                }
-            });
-        self.node_labels
-            .into_iter()
-            .map(|l| {
-                let l = l.into_inner();
-                if l != usize::MAX {
-                    self.chunk_labels[l].load(Ordering::Relaxed)
-                } else {
-                    l
-                }
-            })
-            .collect()
+impl PartialEq<usize> for ConnectedComponent {
+    fn eq(&self, other: &usize) -> bool {
+        self.component_id == *other
     }
 }
 
@@ -211,16 +37,22 @@ pub fn weakly_connected_components<G>(g: &G) -> TypedNodeState<'static, Connecte
 where
     G: StaticGraphViewOps,
 {
-    // read-lock the graph
-    let _cg = g.core_graph().lock();
-    let state = ComponentState::new(g);
-    let result = state.run();
-    TypedNodeState::new(GenericNodeState::new_from_eval_mapped(
+    let index = Index::for_graph(g.clone());
+    let dss = AUnionFind::new(index.len());
+    g.nodes().par_iter().for_each(|node| {
+        let src_node: usize = index.index(&node.node).unwrap();
+        node.out_neighbours().iter().for_each(|nbor| {
+            dss.union(src_node, index.index(&nbor.node).unwrap());
+        })
+    });
+    let result = TypedNodeState::new(GenericNodeState::new_from_eval_with_index_mapped(
         g.clone(),
-        result,
+        dss.to_vec(),
+        index,
         |value| ConnectedComponent {
             component_id: value,
         },
         None,
-    ))
+    ));
+    result
 }
diff --git a/raphtory/src/algorithms/components/in_components.rs b/raphtory/src/algorithms/components/in_components.rs
index 463862904d..1ef30872db 100644
--- a/raphtory/src/algorithms/components/in_components.rs
+++ b/raphtory/src/algorithms/components/in_components.rs
@@ -52,7 +52,7 @@ impl InState {
                 state.base_graph.clone(),
                 state.base_graph.clone(),
                 Const(true),
-                Some(Index::from_iter(value.in_components)),
+                Index::from_iter(value.in_components),
             ),
         }
     }
@@ -95,6 +95,7 @@ where
 {
     let filtered = g.filter(filter)?;
     let ctx: Context<_, _> = (&filtered).into();
+    let index = Index::for_graph(g);
 
     let step1 = ATask::new(move |vv: &mut EvalNodeView<_, InState>| {
         let mut in_components = HashSet::new();
@@ -123,15 +124,17 @@ where
 
     let mut runner = TaskRunner::new(ctx);
 
-    Ok(runner.run(
+    Ok(runner.run_with_index(
+        index,
         vec![Job::new(step1)],
         vec![],
         None,
-        |_, _, _, local: Vec<InState>| {
+        |_, _, _, local: Vec<InState>, index| {
             TypedNodeState::new_mapped(
-                GenericNodeState::new_from_eval(
+                GenericNodeState::new_from_eval_with_index(
                     g.clone(),
                     local,
+                    index,
                     Some(HashMap::from([(
                         "in_components".to_string(),
                         (NodeStateOutputType::Nodes, None),
diff --git a/raphtory/src/algorithms/components/mod.rs b/raphtory/src/algorithms/components/mod.rs
index 13926dca75..2d074df55d 100644
--- a/raphtory/src/algorithms/components/mod.rs
+++ b/raphtory/src/algorithms/components/mod.rs
@@ -4,12 +4,14 @@ mod lcc;
 mod out_components;
 mod scc;
 
-pub use connected_components::weakly_connected_components;
+pub use connected_components::{weakly_connected_components, ConnectedComponent};
 pub use in_components::{
-    in_component, in_component_filtered, in_components, in_components_filtered,
+    in_component, in_component_filtered, in_components, in_components_filtered, InComponentState,
+    InState, TransformedInState,
 };
 pub use lcc::LargestConnectedComponent;
 pub use out_components::{
     out_component, out_component_filtered, out_components, out_components_filtered,
+    OutComponentState,
 };
 pub use scc::strongly_connected_components;
diff --git a/raphtory/src/algorithms/components/out_components.rs b/raphtory/src/algorithms/components/out_components.rs
index d4e793eda5..8596dbafb1 100644
--- a/raphtory/src/algorithms/components/out_components.rs
+++ b/raphtory/src/algorithms/components/out_components.rs
@@ -49,7 +49,7 @@ impl OutState {
                 state.base_graph.clone(),
                 state.base_graph.clone(),
                 Const(true),
-                Some(Index::from_iter(value.out_components)),
+                Index::from_iter(value.out_components),
             ),
         }
     }
@@ -119,16 +119,19 @@ where
     });
 
     let mut runner = TaskRunner::new(ctx);
+    let index = Index::for_graph(g);
 
-    Ok(runner.run(
+    Ok(runner.run_with_index(
+        index,
         vec![Job::new(step1)],
         vec![],
         None,
-        |_, _, _, local: Vec<OutState>| {
+        |_, _, _, local: Vec<OutState>, index| {
             TypedNodeState::new_mapped(
-                GenericNodeState::new_from_eval(
+                GenericNodeState::new_from_eval_with_index(
                     g.clone(),
                     local,
+                    index,
                     Some(HashMap::from([(
                         "out_components".to_string(),
                         (NodeStateOutputType::Nodes, None),
diff --git a/raphtory/src/algorithms/components/scc.rs b/raphtory/src/algorithms/components/scc.rs
index 313538630e..2756848a58 100644
--- a/raphtory/src/algorithms/components/scc.rs
+++ b/raphtory/src/algorithms/components/scc.rs
@@ -2,7 +2,7 @@ use crate::{
     core::entities::VID,
     db::{
         api::{
-            state::{GenericNodeState, TypedNodeState},
+            state::{GenericNodeState, Index, TypedNodeState},
             view::StaticGraphViewOps,
         },
         graph::node::NodeView,
@@ -102,12 +102,14 @@ where
     G: StaticGraphViewOps,
 {
     let groups = tarjan_scc(graph);
+    let index = Index::for_graph(graph);
 
-    let mut values = vec![SCCState::default(); graph.unfiltered_num_nodes()];
+    let mut values = vec![SCCState::default(); index.len()];
 
     for (id, group) in groups.into_iter().enumerate() {
-        for VID(node) in group {
-            values[node] = SCCState { component_id: id };
+        for vid in &group {
+            let pos = index.index(vid).unwrap();
+            values[pos] = SCCState { component_id: id };
         }
     }
 
diff --git a/raphtory/src/algorithms/cores/k_core.rs b/raphtory/src/algorithms/cores/k_core.rs
index 2f4d154d08..e3e266d94a 100644
--- a/raphtory/src/algorithms/cores/k_core.rs
+++ b/raphtory/src/algorithms/cores/k_core.rs
@@ -78,10 +78,10 @@ where
         vec![Job::new(step1)],
         vec![Job::read_only(step2)],
         None,
-        |_, _, _, local| {
+        |_, _, _, local, index| {
             g.nodes()
                 .iter()
-                .filter(|node| local[node.node.0].alive)
+                .filter(|node| local[index.index(&node.node).unwrap()].alive)
                 .map(|node| node.node)
                 .collect()
         },
diff --git a/raphtory/src/algorithms/dynamics/temporal/epidemics.rs b/raphtory/src/algorithms/dynamics/temporal/epidemics.rs
index 17ed0bec78..04f0170c98 100644
--- a/raphtory/src/algorithms/dynamics/temporal/epidemics.rs
+++ b/raphtory/src/algorithms/dynamics/temporal/epidemics.rs
@@ -6,8 +6,12 @@ use crate::{
     },
     prelude::*,
 };
-use rand::{distributions::Bernoulli, seq::IteratorRandom, Rng};
-use rand_distr::{Distribution, Exp};
+use rand::{
+    distr::{Bernoulli, Distribution},
+    seq::IteratorRandom,
+    Rng,
+};
+use rand_distr::Exp;
 use raphtory_api::core::{
     storage::timeindex::AsTime,
     utils::time::{ParseTimeError, TryIntoTime},
@@ -25,7 +29,7 @@ pub struct Probability(f64);
 
 impl Probability {
     pub fn sample<R: Rng + ?Sized>(self, rng: &mut R) -> bool {
-        rng.gen_bool(self.0)
+        rng.random_bool(self.0)
     }
 }
 
@@ -258,13 +262,11 @@ mod test {
         algorithms::dynamics::temporal::epidemics::{temporal_SEIR, Number},
         prelude::*,
     };
-    use rand::{rngs::SmallRng, Rng, SeedableRng};
-    use rand_distr::{Distribution, Exp};
+    use rand::{distr::Distribution, rngs::SmallRng, Rng, SeedableRng};
+    use rand_distr::Exp;
     use raphtory_api::core::utils::logging::global_info_logger;
     use rayon::prelude::*;
     use stats::{mean, stddev};
-    #[cfg(feature = "storage")]
-    use tempfile::TempDir;
     use tracing::info;
 
     fn correct_res(x: f64) -> f64 {
@@ -298,7 +300,7 @@ mod test {
             .scan(0, |v, _| {
                 let new_v: f64 = dist.sample(rng);
                 let floor_v = new_v.floor();
-                let new_v = if rng.gen_bool(new_v - floor_v) {
+                let new_v = if rng.random_bool(new_v - floor_v) {
                     new_v.ceil() as i64
                 } else {
                     floor_v as i64
@@ -386,36 +388,4 @@ mod test {
 
         inner_test(event_rate, recovery_rate, p);
     }
-
-    #[cfg(feature = "storage")]
-    #[test]
-    fn compare_disk_with_in_mem() {
-        let event_rate = 0.00000001;
-        let recovery_rate = 0.000000001;
-        let p = 0.3;
-
-        let mut rng = SmallRng::seed_from_u64(0);
-        let g = generate_graph(1000, event_rate, &mut rng);
-        let test_dir = TempDir::new().unwrap();
-        let disk_graph = g.persist_as_disk_graph(test_dir.path()).unwrap();
-        let mut rng = SmallRng::seed_from_u64(0);
-        let res_arrow = temporal_SEIR(
-            &disk_graph,
-            Some(recovery_rate),
-            None,
-            p,
-            0,
-            Number(1),
-            &mut rng,
-        )
-        .unwrap();
-
-        let mut rng = SmallRng::seed_from_u64(0);
-        let res_mem =
-            temporal_SEIR(&g, Some(recovery_rate), None, p, 0, Number(1), &mut rng).unwrap();
-
-        assert!(res_mem
-            .iter()
-            .all(|(key, val)| res_arrow.get_by_node(key.id()).unwrap() == val));
-    }
 }
diff --git a/raphtory/src/algorithms/embeddings/fast_rp.rs b/raphtory/src/algorithms/embeddings/fast_rp.rs
index 8ae230c593..7b1cbe327b 100644
--- a/raphtory/src/algorithms/embeddings/fast_rp.rs
+++ b/raphtory/src/algorithms/embeddings/fast_rp.rs
@@ -54,7 +54,7 @@ where
     let beta = normalization_strength - 1.0;
     let num_iters = iter_weights.len() - 1;
     let weights = Arc::new(iter_weights);
-    let seed = seed.unwrap_or(rand::thread_rng().gen());
+    let seed = seed.unwrap_or(rand::rng().random());
 
     // initialize each vertex with a random vector according to FastRP's construction rules
     let step1 = {
@@ -98,8 +98,13 @@ where
         vec![Job::new(step1)],
         vec![Job::read_only(step2)],
         None,
-        |_, _, _, local: Vec<FastRPState>| {
-            TypedNodeState::new(GenericNodeState::new_from_eval(g.clone(), local, None))
+        |_, _, _, local: Vec<FastRPState>, index| {
+            TypedNodeState::new(GenericNodeState::new_from_eval_with_index(
+                g.clone(),
+                local,
+                index,
+                None,
+            ))
         },
         threads,
         num_iters,
diff --git a/raphtory/src/algorithms/metrics/clustering_coefficient/local_clustering_coefficient.rs b/raphtory/src/algorithms/metrics/clustering_coefficient/local_clustering_coefficient.rs
index 098f391d27..6e2aea3685 100644
--- a/raphtory/src/algorithms/metrics/clustering_coefficient/local_clustering_coefficient.rs
+++ b/raphtory/src/algorithms/metrics/clustering_coefficient/local_clustering_coefficient.rs
@@ -50,7 +50,8 @@
 
 use crate::{
     algorithms::motifs::local_triangle_count::local_triangle_count,
-    core::entities::nodes::node_ref::AsNodeRef, db::api::view::*,
+    core::entities::nodes::node_ref::AsNodeRef,
+    db::api::view::{internal::GraphView, *},
 };
 
 /// Local clustering coefficient - measures the degree to which a single node in a graph tend to cluster together.
@@ -62,10 +63,7 @@ use crate::{
 ///
 /// # Returns
 /// the local clustering coefficient of node v in g.
-pub fn local_clustering_coefficient<G: StaticGraphViewOps, V: AsNodeRef>(
-    graph: &G,
-    v: V,
-) -> Option<f64> {
+pub fn local_clustering_coefficient<G: GraphView, V: AsNodeRef>(graph: &G, v: V) -> Option<f64> {
     let v = v.as_node_ref();
     if let Some(node) = graph.node(v) {
         if let Some(triangle_count) = local_triangle_count(graph, v) {
diff --git a/raphtory/src/algorithms/metrics/clustering_coefficient/local_clustering_coefficient_batch.rs b/raphtory/src/algorithms/metrics/clustering_coefficient/local_clustering_coefficient_batch.rs
index c2b40785ec..171cee8d79 100644
--- a/raphtory/src/algorithms/metrics/clustering_coefficient/local_clustering_coefficient_batch.rs
+++ b/raphtory/src/algorithms/metrics/clustering_coefficient/local_clustering_coefficient_batch.rs
@@ -8,7 +8,7 @@ use crate::{
     },
 };
 use itertools::Itertools;
-use raphtory_api::core::entities::VID;
+use raphtory_api::core::entities::{LayerIds, VID};
 use rayon::prelude::*;
 use serde::{Deserialize, Serialize};
 
@@ -70,7 +70,12 @@ pub fn local_clustering_coefficient_batch<G: StaticGraphViewOps, V: AsNodeRef>(
     v: Vec<V>,
 ) -> TypedNodeState<'static, LCCState, G> {
     if v.is_empty() {
-        calculate_lcc(graph, (0..graph.unfiltered_num_nodes()).map(VID).collect())
+        calculate_lcc(
+            graph,
+            (0..graph.unfiltered_num_nodes(&LayerIds::All))
+                .map(VID)
+                .collect(),
+        )
     } else {
         calculate_lcc(graph, v)
     }
diff --git a/raphtory/src/algorithms/motifs/global_temporal_three_node_motifs.rs b/raphtory/src/algorithms/motifs/global_temporal_three_node_motifs.rs
index af001d6f80..55629a1dc6 100644
--- a/raphtory/src/algorithms/motifs/global_temporal_three_node_motifs.rs
+++ b/raphtory/src/algorithms/motifs/global_temporal_three_node_motifs.rs
@@ -244,7 +244,7 @@ where
         vec![Job::new(neighbourhood_update_step)],
         vec![Job::new(intersection_compute_step)],
         None,
-        |egs, _, _, _| {
+        |egs, _, _, _, _| {
             tri_mc.iter().map(|mc| egs.finalize::<[usize; 8], [usize;8], [usize; 8], ArrConst<usize,SumDef<usize>,8>>(mc)).collect_vec()
         },
         threads,
@@ -296,7 +296,7 @@ where
         vec![],
         vec![Job::new(star_count_step)],
         None,
-        |egs, _ , _ , _ | {
+        |egs, _ , _ , _ ,_| {
             triadic_motifs.iter().enumerate().map(|(i,tri)| {
                 let mut tmp = egs.finalize::<[usize; 32], [usize;32], [usize; 32], ArrConst<usize,SumDef<usize>,32>>(&star_clone[i])
                 .iter().copied()
diff --git a/raphtory/src/algorithms/motifs/local_temporal_three_node_motifs.rs b/raphtory/src/algorithms/motifs/local_temporal_three_node_motifs.rs
index 0efbe8ec22..fdc77d0e88 100644
--- a/raphtory/src/algorithms/motifs/local_temporal_three_node_motifs.rs
+++ b/raphtory/src/algorithms/motifs/local_temporal_three_node_motifs.rs
@@ -214,19 +214,12 @@ where
         for v in u.neighbours() {
             // Find triangles on the UV edge
             let intersection_nbs = {
-                match (
-                    u.entry(&neighbours_set)
-                        .read_ref()
-                        .unwrap_or(&FxHashSet::default()),
-                    v.entry(&neighbours_set)
-                        .read_ref()
-                        .unwrap_or(&FxHashSet::default()),
-                ) {
-                    (u_set, v_set) => {
-                        let intersection = u_set.intersection(v_set).cloned().collect::<Vec<_>>();
-                        intersection
-                    }
-                }
+                let default = FxHashSet::default();
+                let u_entry = u.entry(&neighbours_set);
+                let u_set = u_entry.read_ref().unwrap_or(&default);
+                let v_entry = v.entry(&neighbours_set);
+                let v_set = v_entry.read_ref().unwrap_or(&default);
+                u_set.intersection(v_set).cloned().collect::<Vec<_>>()
             };
 
             if intersection_nbs.is_empty() {
@@ -304,11 +297,11 @@ where
         vec![Job::new(neighbourhood_update_step)],
         vec![Job::new(intersection_compute_step)],
         None,
-        |_, _, _els, mut local| {
+        |_, _, _els, mut local, index| {
             let mut tri_motifs = HashMap::new();
-            for node in graph.nodes() {
+            for node in kcore_subgraph.nodes() {
                 let v_gid = node.name();
-                let triangle = mem::take(&mut local[node.node.0].triangle);
+                let triangle = mem::take(&mut local[index.index(&node.node).unwrap()].triangle);
                 if triangle.is_empty() {
                     tri_motifs.insert(v_gid.clone(), vec![[0; 8]; delta_len]);
                 } else {
@@ -366,12 +359,12 @@ where
         vec![Job::new(star_motif_step)],
         vec![],
         None,
-        |_, _, _, local| {
+        |_, _, _, local, index| {
             let values: Vec<_> = g
                 .nodes()
                 .par_iter()
                 .map(|n| {
-                    let mc = &local[n.node.index()];
+                    let mc = &local[index.index(&n.node).unwrap()];
                     let v_gid = n.name();
                     let triangles = triadic_motifs
                         .get(&v_gid)
diff --git a/raphtory/src/algorithms/motifs/local_triangle_count.rs b/raphtory/src/algorithms/motifs/local_triangle_count.rs
index 809de17e6d..b97f022c96 100644
--- a/raphtory/src/algorithms/motifs/local_triangle_count.rs
+++ b/raphtory/src/algorithms/motifs/local_triangle_count.rs
@@ -37,7 +37,10 @@
 //! println!("local_triangle_count: {:?}", result);
 //! ```
 
-use crate::{core::entities::nodes::node_ref::AsNodeRef, db::api::view::*};
+use crate::{
+    core::entities::nodes::node_ref::AsNodeRef,
+    db::api::view::{internal::GraphView, *},
+};
 use itertools::Itertools;
 
 /// Local triangle count - calculates the number of triangles (a cycle of length 3) a node participates in.
@@ -51,7 +54,7 @@ use itertools::Itertools;
 /// # Returns
 /// Number of triangles associated with node v
 ///
-pub fn local_triangle_count<G: StaticGraphViewOps, V: AsNodeRef>(graph: &G, v: V) -> Option<usize> {
+pub fn local_triangle_count<G: GraphView, V: AsNodeRef>(graph: &G, v: V) -> Option<usize> {
     if let Some(node) = (&graph).node(v) {
         if node.degree() >= 2 {
             let len = node
diff --git a/raphtory/src/algorithms/motifs/triangle_count.rs b/raphtory/src/algorithms/motifs/triangle_count.rs
index e027a9690a..4e4e47d4b2 100644
--- a/raphtory/src/algorithms/motifs/triangle_count.rs
+++ b/raphtory/src/algorithms/motifs/triangle_count.rs
@@ -107,7 +107,7 @@ pub fn triangle_count<G: StaticGraphViewOps>(graph: &G, threads: Option<usize>)
         init_tasks,
         tasks,
         None,
-        |egs, _, _, _| egs.finalize(&count),
+        |egs, _, _, _, _| egs.finalize(&count),
         threads,
         1,
         None,
diff --git a/raphtory/src/algorithms/motifs/triplet_count.rs b/raphtory/src/algorithms/motifs/triplet_count.rs
index 9cefa80f9c..b8cc4411c2 100644
--- a/raphtory/src/algorithms/motifs/triplet_count.rs
+++ b/raphtory/src/algorithms/motifs/triplet_count.rs
@@ -104,7 +104,7 @@ pub fn triplet_count<G: StaticGraphViewOps>(g: &G, threads: Option<usize>) -> us
         vec![],
         vec![Job::new(step1)],
         None,
-        |egs, _, _, _| egs.finalize(&count),
+        |egs, _, _, _, _| egs.finalize(&count),
         threads,
         1,
         None,
diff --git a/raphtory/src/algorithms/pathing/dijkstra.rs b/raphtory/src/algorithms/pathing/dijkstra.rs
index 6c9a285834..2685c9b5f3 100644
--- a/raphtory/src/algorithms/pathing/dijkstra.rs
+++ b/raphtory/src/algorithms/pathing/dijkstra.rs
@@ -52,7 +52,7 @@ impl DistanceState {
                 state.base_graph.clone(),
                 state.base_graph.clone(),
                 Const(true),
-                Some(Index::from_iter(value.path)),
+                Index::from_iter(value.path),
             ),
         }
     }
@@ -104,6 +104,7 @@ pub fn dijkstra_single_source_shortest_paths<G: StaticGraphViewOps, T: AsNodeRef
     TypedNodeState<'static, DistanceState, G, TransformedDistanceState<'static, G>>,
     GraphError,
 > {
+    let index = Index::for_graph(g);
     let source_ref = source.as_node_ref();
     let source_node = match g.node(source_ref) {
         Some(src) => src,
@@ -124,10 +125,11 @@ pub fn dijkstra_single_source_shortest_paths<G: StaticGraphViewOps, T: AsNodeRef
         }
     }
 
-    let mut target_nodes = vec![false; g.unfiltered_num_nodes()];
+    let mut target_nodes = vec![false; g.count_nodes()];
     for target in targets {
         if let Some(target_node) = g.node(target) {
-            target_nodes[target_node.node.index()] = true;
+            let pos = index.index(&target_node.node).unwrap();
+            target_nodes[pos] = true;
         }
     }
 
@@ -181,7 +183,8 @@ pub fn dijkstra_single_source_shortest_paths<G: StaticGraphViewOps, T: AsNodeRef
         node: node_vid,
     }) = heap.pop()
     {
-        if target_nodes[node_vid.index()] && !paths.contains_key(&node_vid) {
+        let pos = index.index(&node_vid).unwrap();
+        if target_nodes[pos] && !paths.contains_key(&node_vid) {
             let mut path = IndexSet::default();
             path.insert(node_vid);
             let mut current_node_id = node_vid;
diff --git a/raphtory/src/algorithms/pathing/single_source_shortest_path.rs b/raphtory/src/algorithms/pathing/single_source_shortest_path.rs
index 057726c417..a6145aa790 100644
--- a/raphtory/src/algorithms/pathing/single_source_shortest_path.rs
+++ b/raphtory/src/algorithms/pathing/single_source_shortest_path.rs
@@ -2,6 +2,7 @@
 //!
 //! This module provides an implementation of the Single Source Shortest Path algorithm.
 //! It finds the shortest paths from a given source node to all other nodes in a graph.
+
 use crate::{
     core::entities::{nodes::node_ref::AsNodeRef, VID},
     db::{
@@ -40,7 +41,7 @@ impl PathState {
                 state.base_graph.clone(),
                 state.base_graph.clone(),
                 Const(true),
-                Some(Index::from_iter(value.path)),
+                Index::from_iter(value.path),
             ),
         }
     }
diff --git a/raphtory/src/algorithms/pathing/temporal_reachability.rs b/raphtory/src/algorithms/pathing/temporal_reachability.rs
index 483cfab7be..e565653f97 100644
--- a/raphtory/src/algorithms/pathing/temporal_reachability.rs
+++ b/raphtory/src/algorithms/pathing/temporal_reachability.rs
@@ -23,9 +23,8 @@ use crate::{
 use itertools::Itertools;
 use num_traits::Zero;
 use raphtory_api::core::entities::VID;
-use rustc_hash::FxHashMap;
 use serde::{Deserialize, Serialize};
-use std::{collections::HashMap, ops::Add};
+use std::ops::Add;
 
 #[derive(Clone, PartialEq, Serialize, Deserialize, Debug, Default)]
 pub struct ReachabilityState {
@@ -190,30 +189,31 @@ pub fn temporally_reachable_nodes<G: StaticGraphViewOps, T: AsNodeRef>(
     }));
 
     let mut runner: TaskRunner<G, _> = TaskRunner::new(ctx);
-    let result: HashMap<usize, Vec<(i64, String)>> = runner.run(
+    runner.run(
         vec![Job::new(step1)],
         vec![Job::new(step2), step3],
         None,
-        |_, ess, _, _| {
-            ess.finalize(&taint_history, |taint_history| {
+        |_, ess, _, _, index| {
+            let data = ess.finalize_vec(&taint_history, |taint_history| {
                 let mut hist = taint_history
                     .into_iter()
                     .map(|tmsg| (tmsg.event_time, tmsg.src_node))
                     .collect_vec();
                 hist.sort();
-                hist
-            })
+                ReachabilityState {
+                    reachable_nodes: hist,
+                }
+            });
+            TypedNodeState::new(GenericNodeState::new_from_eval_with_index(
+                g.clone(),
+                data,
+                index,
+                None,
+            ))
         },
         threads,
         max_hops,
         None,
         None,
-    );
-    let result: FxHashMap<_, _> = result.into_iter().map(|(k, v)| (VID(k), v)).collect();
-    TypedNodeState::new(GenericNodeState::new_from_map(
-        g.clone(),
-        result,
-        |v| ReachabilityState { reachable_nodes: v },
-        None,
-    ))
+    )
 }
diff --git a/raphtory/src/algorithms/projections/temporal_bipartite_projection.rs b/raphtory/src/algorithms/projections/temporal_bipartite_projection.rs
index 6affa99421..909bc4ab6c 100644
--- a/raphtory/src/algorithms/projections/temporal_bipartite_projection.rs
+++ b/raphtory/src/algorithms/projections/temporal_bipartite_projection.rs
@@ -102,8 +102,8 @@ mod bipartite_graph_tests {
             (11, "B", "4"),
         ];
         for (t, src, dst) in &vs {
-            g.add_node(*t, *src, NO_PROPS, Some("Left")).unwrap();
-            g.add_node(*t, *dst, NO_PROPS, Some("Right")).unwrap();
+            g.add_node(*t, *src, NO_PROPS, Some("Left"), None).unwrap();
+            g.add_node(*t, *dst, NO_PROPS, Some("Right"), None).unwrap();
             g.add_edge(*t, *src, *dst, NO_PROPS, None).unwrap();
         }
         let new_graph = temporal_bipartite_projection(&g, 1, "Right".to_string());
@@ -142,8 +142,8 @@ mod bipartite_graph_tests {
             (11, "B", "4"),
         ];
         for (t, src, dst) in &vs {
-            g.add_node(*t, *src, NO_PROPS, Some("Left")).unwrap();
-            g.add_node(*t, *dst, NO_PROPS, Some("Right")).unwrap();
+            g.add_node(*t, *src, NO_PROPS, Some("Left"), None).unwrap();
+            g.add_node(*t, *dst, NO_PROPS, Some("Right"), None).unwrap();
             g.add_edge(*t, *src, *dst, NO_PROPS, None).unwrap();
         }
         let new_graph = temporal_bipartite_projection(&g, 3, "Right".to_string());
diff --git a/raphtory/src/core/state/compute_state.rs b/raphtory/src/core/state/compute_state.rs
index f604dd81d3..b4ad7e94d5 100644
--- a/raphtory/src/core/state/compute_state.rs
+++ b/raphtory/src/core/state/compute_state.rs
@@ -26,7 +26,11 @@ pub trait ComputeState: std::fmt::Debug + Clone + Send + Sync {
         i: usize,
     ) -> Option<&A>;
 
-    fn iter<A: StateType>(&self, ss: usize, extend_to: usize) -> Box<dyn Iterator<Item = &A> + '_>;
+    fn iter<A: StateType>(
+        &self,
+        ss: usize,
+        extend_to: usize,
+    ) -> Box<dyn Iterator<Item = &A> + Send + '_>;
 
     fn agg<A, IN, OUT, ACC: Accumulator<A, IN, OUT>>(&mut self, ss: usize, a: IN, ki: usize)
     where
@@ -118,7 +122,11 @@ impl ComputeState for ComputeStateVec {
         vec.current(ss).get(i)
     }
 
-    fn iter<A: StateType>(&self, ss: usize, extend_to: usize) -> Box<dyn Iterator<Item = &A> + '_> {
+    fn iter<A: StateType>(
+        &self,
+        ss: usize,
+        extend_to: usize,
+    ) -> Box<dyn Iterator<Item = &A> + Send + '_> {
         let vec = self
             .current()
             .as_any()
diff --git a/raphtory/src/core/state/mod.rs b/raphtory/src/core/state/mod.rs
index 08a0ac9a5d..e4c9cc30ae 100644
--- a/raphtory/src/core/state/mod.rs
+++ b/raphtory/src/core/state/mod.rs
@@ -48,9 +48,9 @@ mod state_test {
     fn tiny_graph() -> Graph {
         let g = Graph::new();
 
-        g.add_node(1, 1, NO_PROPS, None).unwrap();
-        g.add_node(1, 2, NO_PROPS, None).unwrap();
-        g.add_node(1, 3, NO_PROPS, None).unwrap();
+        g.add_node(1, 1, NO_PROPS, None, None).unwrap();
+        g.add_node(1, 2, NO_PROPS, None, None).unwrap();
+        g.add_node(1, 3, NO_PROPS, None, None).unwrap();
         g
     }
 
@@ -63,11 +63,11 @@ mod state_test {
         let mut state_map: MorcelComputeState<ComputeStateVec> = MorcelComputeState::new(3);
 
         // create random vec of numbers
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         let mut vec = vec![];
         let mut actual_min = i32::MAX;
         for _ in 0..100 {
-            let i = rng.gen_range(0..100);
+            let i = rng.random_range(0..100);
             actual_min = actual_min.min(i);
             vec.push(i);
         }
@@ -95,11 +95,11 @@ mod state_test {
         let mut state_map: MorcelComputeState<ComputeStateVec> = MorcelComputeState::new(3);
 
         // create random vec of numbers
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         let mut vec = vec![];
         let mut sum = 0;
         for _ in 0..100 {
-            let i = rng.gen_range(0..100);
+            let i = rng.random_range(0..100);
             sum += i;
             vec.push(i);
         }
@@ -157,11 +157,11 @@ mod state_test {
         let mut state: MorcelComputeState<ComputeStateVec> = MorcelComputeState::new(3);
 
         // create random vec of numbers
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         let mut vec = vec![];
         let mut actual_sum = 0;
         for _ in 0..100 {
-            let i = rng.gen_range(0..100);
+            let i = rng.random_range(0..100);
             actual_sum += i;
             vec.push(i);
         }
@@ -190,19 +190,19 @@ mod state_test {
             ShuffleComputeState::new(3, 2, 2);
 
         // create random vec of numbers
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         let mut vec1 = vec![];
         let mut vec2 = vec![];
         let mut actual_sum_1 = 0;
         let mut actual_sum_2 = 0;
         for _ in 0..3 {
             // data for first partition
-            let i = rng.gen_range(0..100);
+            let i = rng.random_range(0..100);
             actual_sum_1 += i;
             vec1.push(i);
 
             // data for second partition
-            let i = rng.gen_range(0..100);
+            let i = rng.random_range(0..100);
             actual_sum_2 += i;
             vec2.push(i);
         }
@@ -255,7 +255,7 @@ mod state_test {
             ShuffleComputeState::new(3, 2, 2);
 
         // create random vec of numbers
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         let mut vec1 = vec![];
         let mut vec2 = vec![];
         let mut actual_sum_1 = 0;
@@ -264,13 +264,13 @@ mod state_test {
         let mut actual_min_2 = 100;
         for _ in 0..100 {
             // data for first partition
-            let i = rng.gen_range(0..100);
+            let i = rng.random_range(0..100);
             actual_sum_1 += i;
             actual_min_1 = actual_min_1.min(i);
             vec1.push(i);
 
             // data for second partition
-            let i = rng.gen_range(0..100);
+            let i = rng.random_range(0..100);
             actual_sum_2 += i;
             actual_min_2 = actual_min_2.min(i);
             vec2.push(i);
@@ -295,8 +295,9 @@ mod state_test {
 
         let mut actual = part1_state
             .clone()
-            .finalize(&sum, 0, &g, |c| c)
+            .finalize_vec(&sum, 0, &g, |c| c)
             .into_iter()
+            .enumerate()
             .collect_vec();
 
         actual.sort();
@@ -305,8 +306,9 @@ mod state_test {
 
         let mut actual = part1_state
             .clone()
-            .finalize(&min, 0, &g, |c| c)
+            .finalize_vec(&min, 0, &g, |c| c)
             .into_iter()
+            .enumerate()
             .collect_vec();
 
         actual.sort();
@@ -318,8 +320,9 @@ mod state_test {
 
         let mut actual = part2_state
             .clone()
-            .finalize(&sum, 0, &g, |c| c)
+            .finalize_vec(&sum, 0, &g, |c| c)
             .into_iter()
+            .enumerate()
             .collect_vec();
 
         actual.sort();
@@ -328,8 +331,9 @@ mod state_test {
 
         let mut actual = part2_state
             .clone()
-            .finalize(&min, 0, &g, |c| c)
+            .finalize_vec(&min, 0, &g, |c| c)
             .into_iter()
+            .enumerate()
             .collect_vec();
 
         actual.sort();
@@ -342,8 +346,9 @@ mod state_test {
         ShuffleComputeState::merge_mut(&mut part1_state, &part2_state, sum, 0);
         let mut actual = part1_state
             .clone()
-            .finalize(&sum, 0, &g, |c| c)
+            .finalize_vec(&sum, 0, &g, |c| c)
             .into_iter()
+            .enumerate()
             .collect_vec();
 
         actual.sort();
@@ -360,8 +365,9 @@ mod state_test {
         ShuffleComputeState::merge_mut(&mut part1_state, &part2_state, min, 0);
         let mut actual = part1_state
             .clone()
-            .finalize(&min, 0, &g, |c| c)
+            .finalize_vec(&min, 0, &g, |c| c)
             .into_iter()
+            .enumerate()
             .collect_vec();
 
         actual.sort();
diff --git a/raphtory/src/core/state/morcel_state.rs b/raphtory/src/core/state/morcel_state.rs
index f3a8c59481..6a54db9eed 100644
--- a/raphtory/src/core/state/morcel_state.rs
+++ b/raphtory/src/core/state/morcel_state.rs
@@ -138,7 +138,7 @@ impl<CS: ComputeState + Send + Clone> MorcelComputeState<CS> {
         &self,
         ss: usize,
         agg_ref: &AccId<A, IN, OUT, ACC>,
-    ) -> Box<dyn Iterator<Item = Option<&A>> + '_>
+    ) -> Box<dyn Iterator<Item = Option<&A>> + Send + '_>
     where
         A: StateType,
     {
diff --git a/raphtory/src/core/state/shuffle_state.rs b/raphtory/src/core/state/shuffle_state.rs
index 715001395a..440e13ee6a 100644
--- a/raphtory/src/core/state/shuffle_state.rs
+++ b/raphtory/src/core/state/shuffle_state.rs
@@ -128,27 +128,27 @@ impl<CS: ComputeState + Send + Sync> ShuffleComputeState<CS> {
     pub fn accumulate_into<A, IN, OUT, ACC: Accumulator<A, IN, OUT>>(
         &mut self,
         ss: usize,
-        p_id: usize,
+        state_pos: usize,
         a: IN,
         agg_ref: &AccId<A, IN, OUT, ACC>,
     ) where
         A: StateType,
     {
-        let (morcel_id, offset) = self.resolve_pid(p_id);
+        let (morcel_id, offset) = self.resolve_pid(state_pos);
         self.parts[morcel_id].accumulate_into(ss, offset, a, agg_ref)
     }
 
     pub fn read_with_pid<A, IN, OUT, ACC: Accumulator<A, IN, OUT>>(
         &self,
         ss: usize,
-        p_id: usize,
+        state_pos: usize,
         agg_ref: &AccId<A, IN, OUT, ACC>,
     ) -> Option<OUT>
     where
         A: StateType,
         OUT: std::fmt::Debug,
     {
-        let (morcel_id, offset) = self.resolve_pid(p_id);
+        let (morcel_id, offset) = self.resolve_pid(state_pos);
         self.parts[morcel_id].read::<A, IN, OUT, ACC>(offset, agg_ref.id(), ss)
     }
 
@@ -167,27 +167,27 @@ impl<CS: ComputeState + Send + Sync> ShuffleComputeState<CS> {
     pub fn read<A, IN, OUT, ACC: Accumulator<A, IN, OUT>>(
         &self,
         ss: usize,
-        p_id: usize,
+        state_pos: usize,
         agg_ref: &AccId<A, IN, OUT, ACC>,
     ) -> Option<OUT>
     where
         A: StateType,
         OUT: std::fmt::Debug,
     {
-        let (morcel_id, offset) = self.resolve_pid(p_id);
+        let (morcel_id, offset) = self.resolve_pid(state_pos);
         self.parts[morcel_id].read::<A, IN, OUT, ACC>(offset, agg_ref.id(), ss)
     }
 
     pub fn read_ref<A, IN, OUT, ACC: Accumulator<A, IN, OUT>>(
         &self,
         ss: usize,
-        p_id: usize,
+        state_pos: usize,
         agg_ref: &AccId<A, IN, OUT, ACC>,
     ) -> Option<&A>
     where
         A: StateType,
     {
-        let (morcel_id, offset) = self.resolve_pid(p_id);
+        let (morcel_id, offset) = self.resolve_pid(state_pos);
         self.parts[morcel_id].read_ref::<A, IN, OUT, ACC>(offset, agg_ref.id(), ss)
     }
 
@@ -204,13 +204,22 @@ impl<CS: ComputeState + Send + Sync> ShuffleComputeState<CS> {
             .read::<A, IN, OUT, ACC>(GLOBAL_STATE_KEY, agg_ref.id(), ss)
     }
 
-    pub fn finalize<A, B, F, IN, OUT, ACC: Accumulator<A, IN, OUT>, G: StaticGraphViewOps>(
+    pub fn finalize<
+        A,
+        B,
+        F,
+        IN,
+        OUT,
+        ACC: Accumulator<A, IN, OUT>,
+        G: StaticGraphViewOps,
+        C: FromIterator<(usize, B)>,
+    >(
         &self,
         agg_def: &AccId<A, IN, OUT, ACC>,
         ss: usize,
         _g: &G,
         f: F,
-    ) -> HashMap<usize, B>
+    ) -> C
     where
         OUT: StateType,
         A: StateType,
@@ -225,12 +234,33 @@ impl<CS: ComputeState + Send + Sync> ShuffleComputeState<CS> {
             })
             .collect()
     }
+    pub fn finalize_vec<A, B, F, IN, OUT, ACC: Accumulator<A, IN, OUT>, G: StaticGraphViewOps>(
+        &self,
+        agg_def: &AccId<A, IN, OUT, ACC>,
+        ss: usize,
+        _g: &G,
+        f: F,
+    ) -> Vec<B>
+    where
+        OUT: StateType,
+        A: StateType,
+        F: Fn(OUT) -> B + Copy,
+    {
+        self.iter(ss, *agg_def)
+            .map(|(_, a)| {
+                let out = a
+                    .map(|a| ACC::finish(a))
+                    .unwrap_or_else(|| ACC::finish(&ACC::zero()));
+                f(out)
+            })
+            .collect()
+    }
 
     pub fn iter<'a, A: StateType, IN: 'a, OUT: 'a, ACC: Accumulator<A, IN, OUT>>(
         &'a self,
         ss: usize,
         acc_id: AccId<A, IN, OUT, ACC>,
-    ) -> impl Iterator<Item = (usize, Option<&'a A>)> + 'a {
+    ) -> impl Iterator<Item = (usize, Option<&'a A>)> + Send + 'a {
         self.parts
             .iter()
             .flat_map(move |part| part.iter(ss, &acc_id))
@@ -312,6 +342,24 @@ impl<G: StaticGraphViewOps, CS: ComputeState + Send> EvalShardState<G, CS> {
         }
     }
 
+    pub fn finalize_vec<A, B, F, IN, OUT, ACC: Accumulator<A, IN, OUT>>(
+        self,
+        agg_def: &AccId<A, IN, OUT, ACC>,
+        f: F,
+    ) -> Vec<B>
+    where
+        OUT: StateType,
+        A: StateType,
+        F: Fn(OUT) -> B + Copy,
+    {
+        let inner = self.shard_states.consume();
+        if let Ok(inner) = inner {
+            inner.finalize_vec(agg_def, self.ss, &self.g, f)
+        } else {
+            vec![]
+        }
+    }
+
     pub fn values(&self) -> &Shard<CS> {
         &self.shard_states
     }
diff --git a/raphtory/src/db/api/mutation/addition_ops.rs b/raphtory/src/db/api/mutation/addition_ops.rs
index 42d179e795..5fc16b820f 100644
--- a/raphtory/src/db/api/mutation/addition_ops.rs
+++ b/raphtory/src/db/api/mutation/addition_ops.rs
@@ -1,19 +1,29 @@
-use super::time_from_input;
 use crate::{
     core::entities::{edges::edge_ref::EdgeRef, nodes::node_ref::AsNodeRef},
     db::{
-        api::{mutation::CollectProperties, view::StaticGraphViewOps},
+        api::{
+            mutation::time_from_input_session,
+            view::{graph::GraphViewOps, node::NodeViewOps, StaticGraphViewOps},
+        },
         graph::{edge::EdgeView, node::NodeView},
     },
     errors::{into_graph_err, GraphError},
-    prelude::{GraphViewOps, NodeViewOps},
 };
 use raphtory_api::core::{
-    entities::properties::prop::Prop,
-    storage::dict_mapper::MaybeNew::{Existing, New},
+    entities::properties::{
+        meta::{DEFAULT_NODE_TYPE_ID, STATIC_GRAPH_LAYER_ID},
+        prop::Prop,
+    },
     utils::time::{IntoTimeWithFormat, TryIntoInputTime},
 };
-use raphtory_storage::mutation::addition_ops::InternalAdditionOps;
+use raphtory_storage::{
+    durability_ops::DurabilityOps,
+    mutation::{
+        addition_ops::{EdgeWriteLock, InternalAdditionOps, NodeWriteLock},
+        MutationError,
+    },
+};
+use storage::wal::{GraphWalOps, WalOps};
 
 pub trait AdditionOps: StaticGraphViewOps + InternalAdditionOps<Error: Into<GraphError>> {
     // TODO: Probably add vector reference here like add
@@ -35,35 +45,58 @@ pub trait AdditionOps: StaticGraphViewOps + InternalAdditionOps<Error: Into<Grap
     /// ```
     /// use raphtory::prelude::*;
     /// let g = Graph::new();
-    /// let v = g.add_node(0, "Alice", NO_PROPS, None);
-    /// let v = g.add_node(0, 5, NO_PROPS, None);
+    /// let v = g.add_node(0, "Alice", NO_PROPS, None, None);
+    /// let v = g.add_node(0, 5, NO_PROPS, None, None);
     /// ```
-    fn add_node<V: AsNodeRef, T: TryIntoInputTime, PI: CollectProperties>(
+    fn add_node<
+        V: AsNodeRef,
+        T: TryIntoInputTime,
+        PN: AsRef<str>,
+        P: Into<Prop>,
+        PII: IntoIterator<Item = (PN, P)>,
+    >(
         &self,
         t: T,
         v: V,
-        props: PI,
+        props: PII,
         node_type: Option<&str>,
+        layer: Option<&str>,
     ) -> Result<NodeView<'static, Self>, GraphError>;
 
-    fn create_node<V: AsNodeRef, T: TryIntoInputTime, PI: CollectProperties>(
+    /// Add a node to the graph, returning an error if the node already exists.
+    fn create_node<
+        V: AsNodeRef,
+        T: TryIntoInputTime,
+        PN: AsRef<str>,
+        P: Into<Prop>,
+        PI: ExactSizeIterator<Item = (PN, P)>,
+        PII: IntoIterator<Item = (PN, P), IntoIter = PI>,
+    >(
         &self,
         t: T,
         v: V,
-        props: PI,
+        props: PII,
         node_type: Option<&str>,
+        layer: Option<&str>,
     ) -> Result<NodeView<'static, Self>, GraphError>;
 
-    fn add_node_with_custom_time_format<V: AsNodeRef, PI: CollectProperties>(
+    fn add_node_with_custom_time_format<
+        V: AsNodeRef,
+        PN: AsRef<str>,
+        P: Into<Prop>,
+        PI: ExactSizeIterator<Item = (PN, P)>,
+        PII: IntoIterator<Item = (PN, P), IntoIter = PI>,
+    >(
         &self,
         t: &str,
         fmt: &str,
         v: V,
-        props: PI,
+        props: PII,
         node_type: Option<&str>,
+        layer: Option<&str>,
     ) -> Result<NodeView<'static, Self>, GraphError> {
         let time: i64 = t.parse_time(fmt)?;
-        self.add_node(time, v, props, node_type)
+        self.add_node(time, v, props, node_type, layer)
     }
 
     // TODO: Node.name which gets ._id property else numba as string
@@ -82,135 +115,324 @@ pub trait AdditionOps: StaticGraphViewOps + InternalAdditionOps<Error: Into<Grap
     /// use raphtory::prelude::*;
     ///
     /// let graph = Graph::new();
-    /// graph.add_node(1, "Alice", NO_PROPS, None).unwrap();
-    /// graph.add_node(2, "Bob", NO_PROPS, None).unwrap();
+    /// graph.add_node(1, "Alice", NO_PROPS, None, None).unwrap();
+    /// graph.add_node(2, "Bob", NO_PROPS, None, None).unwrap();
     /// graph.add_edge(3, "Alice", "Bob", NO_PROPS, None).unwrap();
-    /// ```    
-    fn add_edge<V: AsNodeRef, T: TryIntoInputTime, PI: CollectProperties>(
+    /// ```
+    fn add_edge<
+        V: AsNodeRef,
+        T: TryIntoInputTime,
+        PN: AsRef<str>,
+        P: Into<Prop>,
+        PI: ExactSizeIterator<Item = (PN, P)>,
+        PII: IntoIterator<Item = (PN, P), IntoIter = PI>,
+    >(
         &self,
         t: T,
         src: V,
         dst: V,
-        props: PI,
+        props: PII,
         layer: Option<&str>,
     ) -> Result<EdgeView<Self>, GraphError>;
 
-    fn add_edge_with_custom_time_format<V: AsNodeRef, PI: CollectProperties>(
+    fn add_edge_with_custom_time_format<
+        V: AsNodeRef,
+        PN: AsRef<str>,
+        P: Into<Prop>,
+        PI: ExactSizeIterator<Item = (PN, P)>,
+        PII: IntoIterator<Item = (PN, P), IntoIter = PI>,
+    >(
         &self,
         t: &str,
         fmt: &str,
         src: V,
         dst: V,
-        props: PI,
+        props: PII,
         layer: Option<&str>,
     ) -> Result<EdgeView<Self>, GraphError> {
         let time: i64 = t.parse_time(fmt)?;
         self.add_edge(time, src, dst, props, layer)
     }
+
+    fn flush(&self) -> Result<(), Self::Error>;
 }
 
 impl<G: InternalAdditionOps<Error: Into<GraphError>> + StaticGraphViewOps> AdditionOps for G {
-    fn add_node<V: AsNodeRef, T: TryIntoInputTime, PI: CollectProperties>(
+    fn add_node<
+        V: AsNodeRef,
+        T: TryIntoInputTime,
+        PN: AsRef<str>,
+        P: Into<Prop>,
+        PII: IntoIterator<Item = (PN, P)>,
+    >(
         &self,
         t: T,
         v: V,
-        props: PI,
+        props: PII,
         node_type: Option<&str>,
+        layer: Option<&str>,
     ) -> Result<NodeView<'static, G>, GraphError> {
-        let ti = time_from_input(self, t)?;
-        let properties = props.collect_properties(|name, dtype| {
-            Ok(self
-                .resolve_node_property(name, dtype, false)
-                .map_err(into_graph_err)?
-                .inner())
-        })?;
-        let v_id = match node_type {
-            None => self
-                .resolve_node(v.as_node_ref())
-                .map_err(into_graph_err)?
-                .inner(),
-            Some(node_type) => {
-                let (v_id, _) = self
-                    .resolve_node_and_type(v.as_node_ref(), node_type)
-                    .map_err(into_graph_err)?
-                    .inner();
-                v_id.inner()
-            }
-        };
-        self.internal_add_node(ti, v_id, &properties)
-            .map_err(into_graph_err)?;
-        Ok(NodeView::new_internal(self.clone(), v_id))
+        let error_if_exists = false;
+        add_node_impl(self, t, v, props, node_type, error_if_exists, layer)
     }
 
-    fn create_node<V: AsNodeRef, T: TryIntoInputTime, PI: CollectProperties>(
+    fn create_node<
+        V: AsNodeRef,
+        T: TryIntoInputTime,
+        PN: AsRef<str>,
+        P: Into<Prop>,
+        PI: ExactSizeIterator<Item = (PN, P)>,
+        PII: IntoIterator<Item = (PN, P), IntoIter = PI>,
+    >(
         &self,
         t: T,
         v: V,
-        props: PI,
+        props: PII,
         node_type: Option<&str>,
+        layer: Option<&str>,
     ) -> Result<NodeView<'static, G>, GraphError> {
-        let ti = time_from_input(self, t)?;
-        let v_id = match node_type {
-            None => self.resolve_node(v.as_node_ref()).map_err(into_graph_err)?,
-            Some(node_type) => {
-                let (v_id, _) = self
-                    .resolve_node_and_type(v.as_node_ref(), node_type)
-                    .map_err(into_graph_err)?
-                    .inner();
-                v_id
-            }
-        };
-        match v_id {
-            New(id) => {
-                let properties = props.collect_properties(|name, dtype| {
-                    Ok(self
-                        .resolve_node_property(name, dtype, false)
-                        .map_err(into_graph_err)?
-                        .inner())
-                })?;
-                self.internal_add_node(ti, id, &properties)
-                    .map_err(into_graph_err)?;
-                Ok(NodeView::new_internal(self.clone(), id))
-            }
-            Existing(id) => {
-                let node_id = self.node(id).unwrap().id();
-                Err(GraphError::NodeExistsError(node_id))
-            }
-        }
+        let error_if_exists = true;
+        add_node_impl(self, t, v, props, node_type, error_if_exists, layer)
     }
 
-    fn add_edge<V: AsNodeRef, T: TryIntoInputTime, PI: CollectProperties>(
+    fn add_edge<
+        V: AsNodeRef,
+        T: TryIntoInputTime,
+        PN: AsRef<str>,
+        P: Into<Prop>,
+        PI: ExactSizeIterator<Item = (PN, P)>,
+        PII: IntoIterator<Item = (PN, P), IntoIter = PI>,
+    >(
         &self,
         t: T,
         src: V,
         dst: V,
-        props: PI,
+        props: PII,
         layer: Option<&str>,
     ) -> Result<EdgeView<G>, GraphError> {
-        let ti = time_from_input(self, t)?;
-        let src_id = self
-            .resolve_node(src.as_node_ref())
-            .map_err(into_graph_err)?
-            .inner();
-        let dst_id = self
-            .resolve_node(dst.as_node_ref())
-            .map_err(into_graph_err)?
-            .inner();
+        let transaction_manager = self.core_graph().transaction_manager()?;
+        let wal = self.core_graph().wal()?;
+        let transaction_id = transaction_manager.begin_transaction();
+        let session = self.write_session().map_err(|err| err.into())?;
+        let src = src.as_node_ref();
+        let dst = dst.as_node_ref();
+
+        self.validate_gids(
+            [src, dst]
+                .iter()
+                .filter_map(|node_ref| node_ref.as_gid_ref()),
+        )
+        .map_err(into_graph_err)?;
+
+        let props_with_status = self
+            .validate_props_with_status(
+                false,
+                self.edge_meta(),
+                props.into_iter().map(|(k, v)| (k, v.into())),
+            )
+            .map_err(into_graph_err)?;
+
+        let ti = time_from_input_session(&session, t)?;
+        let src_gid = src.as_gid_ref();
+        let dst_gid = dst.as_gid_ref();
         let layer_id = self.resolve_layer(layer).map_err(into_graph_err)?.inner();
 
-        let properties: Vec<(usize, Prop)> = props.collect_properties(|name, dtype| {
-            Ok(self
-                .resolve_edge_property(name, dtype, false)
-                .map_err(into_graph_err)?
-                .inner())
-        })?;
-        let eid = self
-            .internal_add_edge(ti, src_id, dst_id, &properties, layer_id)
-            .map_err(into_graph_err)?
-            .inner();
+        // Hold all locks for src node, dst node and edge until writer goes out of scope.
+        let mut writer = self
+            .atomic_add_edge(src, dst, None)
+            .map_err(into_graph_err)?;
+
+        let src_id = writer.src().inner();
+        let dst_id = writer.dst().inner();
+        let edge_id = writer.eid().inner();
+
+        let props_for_wal = props_with_status
+            .iter()
+            .map(|maybe_new| {
+                let (prop_name, prop_id, prop) = maybe_new.as_ref().inner();
+                (prop_name.as_ref(), *prop_id, prop.clone())
+            })
+            .collect::<Vec<_>>();
+
+        // NOTE: We log edge id after it is inserted into the edge segment.
+        // This is fine as long as we hold onto the edge segment lock through writer
+        // for the entire operation.
+        let lsn = wal.log_add_edge(
+            transaction_id,
+            ti,
+            src_gid,
+            src_id,
+            dst_gid,
+            dst_id,
+            edge_id,
+            layer,
+            layer_id,
+            props_for_wal,
+        )?;
+
+        let props = props_with_status
+            .into_iter()
+            .map(|maybe_new| {
+                let (_, prop_id, prop) = maybe_new.inner();
+                (prop_id, prop)
+            })
+            .collect::<Vec<_>>();
+
+        writer.internal_add_update(ti, layer_id, props);
+
+        // Update the src, dst and edge segments with the lsn of the wal entry.
+        writer.set_lsn(lsn);
+
+        transaction_manager.end_transaction(transaction_id);
+
+        // Segment locks can be released before flush to allow
+        // other operations to proceed.
+        drop(writer);
+
+        // Flush the wal entry to disk.
+        // Any error here is fatal.
+        if let Err(e) = wal.flush(lsn) {
+            return Err(GraphError::FatalWriteError(e));
+        }
+
         Ok(EdgeView::new(
             self.clone(),
-            EdgeRef::new_outgoing(eid, src_id, dst_id).at_layer(layer_id),
+            EdgeRef::new_outgoing(edge_id, src_id, dst_id).at_layer(layer_id),
         ))
     }
+
+    fn flush(&self) -> Result<(), Self::Error> {
+        self.core_graph()
+            .flush()
+            .map_err(|err| MutationError::from(err).into())
+    }
+}
+
+fn add_node_impl<
+    G: InternalAdditionOps<Error: Into<GraphError>> + StaticGraphViewOps,
+    V: AsNodeRef,
+    T: TryIntoInputTime,
+    PN: AsRef<str>,
+    P: Into<Prop>,
+    PII: IntoIterator<Item = (PN, P)>,
+>(
+    graph: &G,
+    t: T,
+    v: V,
+    props: PII,
+    node_type: Option<&str>,
+    error_if_exists: bool,
+    layer: Option<&str>,
+) -> Result<NodeView<'static, G>, GraphError> {
+    let transaction_manager = graph.core_graph().transaction_manager()?;
+    let wal = graph.core_graph().wal()?;
+    let transaction_id = transaction_manager.begin_transaction();
+    let session = graph.write_session().map_err(|err| err.into())?;
+    let node_ref = v.as_node_ref();
+
+    graph
+        .validate_gids(
+            [node_ref]
+                .iter()
+                .filter_map(|node_ref| node_ref.as_gid_ref()),
+        )
+        .map_err(into_graph_err)?;
+
+    let props_with_status = graph
+        .validate_props_with_status(
+            false,
+            graph.node_meta(),
+            props.into_iter().map(|(k, v)| (k, v.into())),
+        )
+        .map_err(into_graph_err)?;
+
+    let node_gid = node_ref.as_gid_ref();
+    let ti = time_from_input_session(&session, t)?;
+    let mut writer = graph.atomic_add_node(node_ref).map_err(into_graph_err)?;
+
+    let node_type_id = match node_type {
+        None => DEFAULT_NODE_TYPE_ID,
+        Some(node_type) => {
+            if writer.can_set_type() {
+                let node_type_id = graph
+                    .node_meta()
+                    .get_or_create_node_type_id(node_type)
+                    .inner();
+                writer.set_type(node_type_id);
+                node_type_id
+            } else {
+                // this can only happen for an existing node so no modification of the graph occurred
+                graph
+                    .node_meta()
+                    .get_node_type_id(node_type)
+                    .filter(|&node_type_id| writer.get_type() == node_type_id)
+                    .ok_or(MutationError::NodeTypeError)?
+            }
+        }
+    };
+
+    let is_new = writer.node().is_new();
+    let node_id = writer.node().inner();
+
+    if error_if_exists && !is_new {
+        drop(writer);
+        let node_id = graph.node(node_id).unwrap().id();
+        return Err(GraphError::NodeExistsError(node_id));
+    }
+
+    // We don't care about logging the default node type.
+    let node_type_and_id = Some(node_type_id)
+        .filter(|&id| id != DEFAULT_NODE_TYPE_ID)
+        .and_then(|id| node_type.map(|name| (name, id)));
+
+    let props = props_with_status
+        .iter()
+        .map(|maybe_new| {
+            let (_, prop_id, prop) = maybe_new.as_ref().inner();
+            (*prop_id, prop.clone())
+        })
+        .collect::<Vec<_>>();
+
+    let layer_id = match layer {
+        None => STATIC_GRAPH_LAYER_ID,
+        Some(_) => graph.resolve_layer(layer).map_err(into_graph_err)?.inner(),
+    };
+
+    writer.internal_add_update(ti, layer_id, props);
+
+    let props_for_wal = props_with_status
+        .iter()
+        .map(|maybe_new| {
+            let (prop_name, prop_id, prop) = maybe_new.as_ref().inner();
+            (prop_name.as_ref(), *prop_id, prop.clone())
+        })
+        .collect::<Vec<_>>();
+
+    // Create a wal entry to mark operation as durable.
+    let lsn = wal.log_add_node(
+        transaction_id,
+        ti,
+        node_gid,
+        node_id,
+        node_type_and_id,
+        props_for_wal,
+        layer,
+        layer_id,
+    )?;
+
+    // Update node segment with the lsn of the wal entry.
+    writer.set_lsn(lsn);
+    transaction_manager.end_transaction(transaction_id);
+
+    // Segment lock can be released before flush to allow
+    // other operations to proceed.
+    drop(writer);
+
+    // Flush the wal entry to disk.
+    // Any error here is fatal.
+    if let Err(e) = wal.flush(lsn) {
+        return Err(GraphError::FatalWriteError(e));
+    }
+
+    Ok(NodeView::new_internal(graph.clone(), node_id))
 }
diff --git a/raphtory/src/db/api/mutation/deletion_ops.rs b/raphtory/src/db/api/mutation/deletion_ops.rs
index 0514ac4f2d..2293e8c084 100644
--- a/raphtory/src/db/api/mutation/deletion_ops.rs
+++ b/raphtory/src/db/api/mutation/deletion_ops.rs
@@ -1,22 +1,23 @@
-use super::time_from_input;
 use crate::{
     core::entities::nodes::node_ref::AsNodeRef,
-    db::{api::view::StaticGraphViewOps, graph::edge::EdgeView},
+    db::{
+        api::{
+            mutation::{time_from_input_session, TryIntoInputTime},
+            view::StaticGraphViewOps,
+        },
+        graph::edge::EdgeView,
+    },
     errors::{into_graph_err, GraphError},
 };
-use raphtory_api::core::{
-    entities::edges::edge_ref::EdgeRef,
-    utils::time::{IntoTimeWithFormat, TryIntoInputTime},
-};
-use raphtory_storage::mutation::{
-    addition_ops::InternalAdditionOps, deletion_ops::InternalDeletionOps,
+use raphtory_api::core::{entities::edges::edge_ref::EdgeRef, utils::time::IntoTimeWithFormat};
+use raphtory_storage::{
+    durability_ops::DurabilityOps,
+    mutation::addition_ops::{EdgeWriteLock, InternalAdditionOps},
 };
+use storage::wal::{GraphWalOps, WalOps};
 
 pub trait DeletionOps:
-    InternalDeletionOps<Error: Into<GraphError>>
-    + InternalAdditionOps<Error: Into<GraphError>>
-    + StaticGraphViewOps
-    + Sized
+    InternalAdditionOps<Error: Into<GraphError>> + StaticGraphViewOps + Sized
 {
     fn delete_edge<V: AsNodeRef, T: TryIntoInputTime>(
         &self,
@@ -25,23 +26,58 @@ pub trait DeletionOps:
         dst: V,
         layer: Option<&str>,
     ) -> Result<EdgeView<Self>, GraphError> {
-        let ti = time_from_input(self, t).map_err(into_graph_err)?;
-        let src_id = self
-            .resolve_node(src.as_node_ref())
-            .map_err(into_graph_err)?
-            .inner();
-        let dst_id = self
-            .resolve_node(dst.as_node_ref())
-            .map_err(into_graph_err)?
-            .inner();
-        let layer = self.resolve_layer(layer).map_err(into_graph_err)?.inner();
-        let eid = self
-            .internal_delete_edge(ti, src_id, dst_id, layer)
-            .map_err(into_graph_err)?
-            .inner();
+        let transaction_manager = self.core_graph().transaction_manager()?;
+        let wal = self.core_graph().wal()?;
+        let transaction_id = transaction_manager.begin_transaction();
+        let session = self.write_session().map_err(|err| err.into())?;
+        let src = src.as_node_ref();
+        let dst = dst.as_node_ref();
+
+        self.validate_gids(
+            [src, dst]
+                .iter()
+                .filter_map(|node_ref| node_ref.as_gid_ref()),
+        )
+        .map_err(into_graph_err)?;
+
+        let ti = time_from_input_session(&session, t)?;
+        let src_gid = src.as_gid_ref();
+        let dst_gid = dst.as_gid_ref();
+        let layer_id = self.resolve_layer(layer).map_err(into_graph_err)?.inner();
+
+        let mut writer = self
+            .atomic_add_edge(src, dst, None)
+            .map_err(into_graph_err)?;
+
+        let src_id = writer.src().inner();
+        let dst_id = writer.dst().inner();
+        let edge_id = writer.eid().inner();
+
+        let lsn = wal.log_delete_edge(
+            transaction_id,
+            ti,
+            src_gid,
+            src_id,
+            dst_gid,
+            dst_id,
+            edge_id,
+            layer,
+            layer_id,
+        )?;
+
+        writer.internal_delete_edge(ti, layer_id);
+
+        writer.set_lsn(lsn);
+        transaction_manager.end_transaction(transaction_id);
+        drop(writer);
+
+        if let Err(e) = wal.flush(lsn) {
+            return Err(GraphError::FatalWriteError(e));
+        }
+
         Ok(EdgeView::new(
             self.clone(),
-            EdgeRef::new_outgoing(eid, src_id, dst_id).at_layer(layer),
+            EdgeRef::new_outgoing(edge_id, src_id, dst_id).at_layer(layer_id),
         ))
     }
 
@@ -58,11 +94,7 @@ pub trait DeletionOps:
     }
 }
 
-impl<
-        T: InternalDeletionOps<Error: Into<GraphError>>
-            + InternalAdditionOps<Error: Into<GraphError>>
-            + StaticGraphViewOps
-            + Sized,
-    > DeletionOps for T
+impl<T: InternalAdditionOps<Error: Into<GraphError>> + StaticGraphViewOps + Sized> DeletionOps
+    for T
 {
 }
diff --git a/raphtory/src/db/api/mutation/import_ops.rs b/raphtory/src/db/api/mutation/import_ops.rs
index dd044a9660..f7e7cff599 100644
--- a/raphtory/src/db/api/mutation/import_ops.rs
+++ b/raphtory/src/db/api/mutation/import_ops.rs
@@ -1,9 +1,8 @@
-use super::time_from_input;
 use crate::{
     core::entities::nodes::node_ref::AsNodeRef,
     db::{
         api::{
-            properties::internal::InternalTemporalPropertiesOps,
+            mutation::time_from_input_session,
             view::{
                 internal::{GraphView, InternalMaterialize},
                 StaticGraphViewOps,
@@ -22,8 +21,7 @@ use raphtory_api::core::{
     storage::{arc_str::OptionAsStr, timeindex::AsTime},
 };
 use raphtory_storage::mutation::{
-    addition_ops::InternalAdditionOps, deletion_ops::InternalDeletionOps,
-    property_addition_ops::InternalPropertyAdditionOps,
+    addition_ops::InternalAdditionOps, property_addition_ops::InternalPropertyAdditionOps,
 };
 use std::{borrow::Borrow, fmt::Debug};
 
@@ -288,38 +286,38 @@ fn import_node_internal<
     merge: bool,
 ) -> Result<NodeView<'static, G>, GraphError> {
     let id = id.as_node_ref();
+    let gid_ref = id.as_gid_ref();
+    graph.validate_gids(gid_ref).map_err(into_graph_err)?;
     if !merge {
         if let Some(existing_node) = graph.node(id) {
             return Err(GraphError::NodeExistsError(existing_node.id()));
         }
     }
 
-    let node_internal = match node.node_type().as_str() {
-        None => graph.resolve_node(id).map_err(into_graph_err)?.inner(),
-        Some(node_type) => {
-            let (node_internal, _) = graph
-                .resolve_node_and_type(id, node_type)
-                .map_err(into_graph_err)?
-                .inner();
-            node_internal.inner()
-        }
-    };
-    let keys = node.temporal_prop_keys().collect::<Vec<_>>();
+    let (node_internal, _) = graph
+        .resolve_and_update_node_and_type(id, node.node_type().as_str())
+        .map_err(into_graph_err)?
+        .inner();
+    let node_internal = node_internal.inner();
+    let session = graph.write_session().map_err(|err| err.into())?;
+    let keys = node.graph.node_meta().temporal_prop_mapper().all_keys();
 
-    for (t, row) in node.rows() {
-        let t = time_from_input(graph, t)?;
+    for (t, l, row) in node.rows() {
+        let t = time_from_input_session(&session, t)?;
 
-        let props = row
-            .into_iter()
-            .zip(&keys)
-            .map(|((_, prop), key)| {
-                let prop_id = graph.resolve_node_property(key, prop.dtype(), false);
-                prop_id.map(|prop_id| (prop_id.inner(), prop))
-            })
-            .collect::<Result<Vec<_>, _>>()
+        let props = graph
+            .validate_props(
+                false,
+                graph.node_meta(),
+                row.into_iter().map(|(prop_id, prop)| {
+                    let prop_key = &keys[prop_id];
+                    (prop_key, prop)
+                }),
+            )
             .map_err(into_graph_err)?;
+
         graph
-            .internal_add_node(t, node_internal, &props)
+            .internal_add_node(t, node_internal, props, l)
             .map_err(into_graph_err)?;
     }
 
@@ -355,12 +353,13 @@ fn import_edge_internal<
     }
 
     // Add edges first to ensure associated nodes are present
+    let session = graph.write_session().map_err(|err| err.into())?;
     for ee in edge.explode_layers() {
         let layer_name = ee.layer_name().expect("exploded layers");
 
         for ee in ee.explode() {
             graph.add_edge(
-                ee.time().expect("exploded edge"),
+                ee.time().expect("exploded edge").t(),
                 &src_id,
                 &dst_id,
                 ee.properties().temporal().collect_properties(),
@@ -369,16 +368,8 @@ fn import_edge_internal<
         }
 
         for (t, _) in edge.deletions_hist() {
-            let ti = time_from_input(graph, t.t())?;
-            let src_node = graph.resolve_node(src_id).map_err(into_graph_err)?.inner();
-            let dst_node = graph.resolve_node(dst_id).map_err(into_graph_err)?.inner();
-            let layer = graph
-                .resolve_layer(Some(&layer_name))
-                .map_err(into_graph_err)?
-                .inner();
-            graph
-                .internal_delete_edge(ti, src_node, dst_node, layer)
-                .map_err(into_graph_err)?;
+            let ti = time_from_input_session(&session, t.t())?;
+            graph.delete_edge(ti.t(), src_id, dst_id, Some(&layer_name))?;
         }
 
         graph
@@ -391,11 +382,7 @@ fn import_edge_internal<
 }
 
 fn check_existing_nodes<
-    G: StaticGraphViewOps
-        + InternalAdditionOps
-        + InternalDeletionOps
-        + InternalPropertyAdditionOps
-        + InternalMaterialize,
+    G: StaticGraphViewOps + InternalAdditionOps + InternalPropertyAdditionOps + InternalMaterialize,
     V: AsNodeRef,
 >(
     graph: &G,
@@ -417,11 +404,7 @@ fn check_existing_nodes<
 }
 
 fn check_existing_edges<
-    G: StaticGraphViewOps
-        + InternalAdditionOps
-        + InternalDeletionOps
-        + InternalPropertyAdditionOps
-        + InternalMaterialize,
+    G: StaticGraphViewOps + InternalAdditionOps + InternalPropertyAdditionOps + InternalMaterialize,
     V: AsNodeRef + Clone + Debug,
 >(
     graph: &G,
diff --git a/raphtory/src/db/api/mutation/index_ops.rs b/raphtory/src/db/api/mutation/index_ops.rs
index 0502bd7b29..8be7709aee 100644
--- a/raphtory/src/db/api/mutation/index_ops.rs
+++ b/raphtory/src/db/api/mutation/index_ops.rs
@@ -2,10 +2,14 @@ use crate::{
     db::api::view::{IndexSpec, IndexSpecBuilder},
     errors::GraphError,
     prelude::AdditionOps,
-    serialise::GraphFolder,
+    serialise::{GraphFolder, GraphPaths},
 };
-use std::{fs::File, path::Path};
-use zip::ZipArchive;
+use std::{
+    fs::File,
+    io::{Seek, Write},
+    path::Path,
+};
+use zip::{ZipArchive, ZipWriter};
 
 /// Mutation operations for managing indexes.
 pub trait IndexMutationOps: Sized + AdditionOps {
@@ -55,7 +59,7 @@ pub trait IndexMutationOps: Sized + AdditionOps {
     ///
     /// Returns:
     ///     None:
-    fn persist_index_to_disk(&self, path: &GraphFolder) -> Result<(), GraphError>;
+    fn persist_index_to_disk(&self, path: &impl GraphPaths) -> Result<(), GraphError>;
 
     /// Persists the current index to disk as a compressed ZIP file at the specified path.
     ///
@@ -64,7 +68,11 @@ pub trait IndexMutationOps: Sized + AdditionOps {
     ///
     /// Returns:
     ///     None:
-    fn persist_index_to_disk_zip(&self, path: &GraphFolder) -> Result<(), GraphError>;
+    fn persist_index_to_disk_zip<W: Write + Seek>(
+        &self,
+        writer: &mut ZipWriter<W>,
+        prefix: &str,
+    ) -> Result<(), GraphError>;
 
     /// Drops (removes) the current index from the database.
     ///
@@ -138,13 +146,13 @@ impl<G: AdditionOps> IndexMutationOps for G {
         self.get_storage()
             .map_or(Err(GraphError::IndexingNotSupported), |storage| {
                 if path.is_zip() {
-                    if has_index(path.get_base_path())? {
+                    if has_index(path.root())? {
                         storage.load_index_if_empty(&path)?;
                     } else {
                         return Ok(()); // Skip if no index in zip
                     }
                 } else {
-                    let index_path = path.get_index_path();
+                    let index_path = path.index_path()?;
                     if index_path.exists() && index_path.read_dir()?.next().is_some() {
                         storage.load_index_if_empty(&path)?;
                     }
@@ -154,20 +162,22 @@ impl<G: AdditionOps> IndexMutationOps for G {
             })
     }
 
-    fn persist_index_to_disk(&self, path: &GraphFolder) -> Result<(), GraphError> {
+    fn persist_index_to_disk(&self, path: &impl GraphPaths) -> Result<(), GraphError> {
         self.get_storage()
             .map_or(Err(GraphError::IndexingNotSupported), |storage| {
-                storage.persist_index_to_disk(&path)?;
+                storage.persist_index_to_disk(path)?;
                 Ok(())
             })
     }
 
-    fn persist_index_to_disk_zip(&self, path: &GraphFolder) -> Result<(), GraphError> {
+    fn persist_index_to_disk_zip<W: Write + Seek>(
+        &self,
+        writer: &mut ZipWriter<W>,
+        prefix: &str,
+    ) -> Result<(), GraphError> {
         self.get_storage()
-            .map_or(Err(GraphError::IndexingNotSupported), |storage| {
-                storage.persist_index_to_disk_zip(&path)?;
-                Ok(())
-            })
+            .ok_or(GraphError::IndexingNotSupported)?
+            .persist_index_to_disk_zip(writer, prefix)
     }
 
     fn drop_index(&self) -> Result<(), GraphError> {
diff --git a/raphtory/src/db/api/mutation/mod.rs b/raphtory/src/db/api/mutation/mod.rs
index ba36c09ebd..08edcabcdb 100644
--- a/raphtory/src/db/api/mutation/mod.rs
+++ b/raphtory/src/db/api/mutation/mod.rs
@@ -1,10 +1,3 @@
-use crate::{
-    errors::{into_graph_err, GraphError},
-    prelude::Prop,
-};
-use raphtory_api::core::{entities::properties::prop::PropType, storage::timeindex::EventTime};
-use raphtory_storage::mutation::addition_ops::InternalAdditionOps;
-
 mod addition_ops;
 mod deletion_ops;
 mod import_ops;
@@ -12,49 +5,49 @@ mod import_ops;
 pub mod index_ops;
 mod property_addition_ops;
 
+use crate::errors::{into_graph_err, GraphError};
 pub use addition_ops::AdditionOps;
 pub use deletion_ops::DeletionOps;
 pub use import_ops::ImportOps;
 #[cfg(feature = "search")]
 pub use index_ops::IndexMutationOps;
 pub use property_addition_ops::PropertyAdditionOps;
-pub(crate) use raphtory_api::core::utils::time::{InputTime, TryIntoInputTime};
+use raphtory_api::core::{
+    storage::timeindex::EventTime,
+    utils::time::{InputTime, TryIntoInputTime},
+};
+use raphtory_storage::mutation::addition_ops::{InternalAdditionOps, SessionAdditionOps};
 
 pub fn time_from_input<G: InternalAdditionOps<Error: Into<GraphError>>, T: TryIntoInputTime>(
-    g: &G,
-    t: T,
+    graph: &G,
+    time: T,
 ) -> Result<EventTime, GraphError> {
-    let t = t.try_into_input_time()?;
-    Ok(match t {
-        InputTime::Simple(t) => EventTime::new(t, g.next_event_id().map_err(into_graph_err)?),
-        InputTime::Indexed(t, s) => EventTime::new(t, s),
+    let input_time = time.try_into_input_time()?;
+    let session = graph.write_session().map_err(|err| err.into())?;
+
+    Ok(match input_time {
+        InputTime::Simple(t) => EventTime::new(t, session.next_event_id().map_err(into_graph_err)?),
+        InputTime::Indexed(t, secondary_index) => EventTime::new(t, secondary_index),
     })
 }
 
-pub trait CollectProperties {
-    fn collect_properties<F: Fn(&str, PropType) -> Result<usize, GraphError>>(
-        self,
-        id_resolver: F,
-    ) -> Result<Vec<(usize, Prop)>, GraphError>;
-}
+pub fn time_from_input_session<
+    G: SessionAdditionOps<Error: Into<GraphError>>,
+    T: TryIntoInputTime,
+>(
+    graph: &G,
+    time: T,
+) -> Result<EventTime, GraphError> {
+    let input_time = time.try_into_input_time()?;
 
-impl<S: AsRef<str>, P: Into<Prop>, PI> CollectProperties for PI
-where
-    PI: IntoIterator<Item = (S, P)>,
-{
-    fn collect_properties<F: Fn(&str, PropType) -> Result<usize, GraphError>>(
-        self,
-        id_resolver: F,
-    ) -> Result<Vec<(usize, Prop)>, GraphError>
-    where
-        PI: IntoIterator<Item = (S, P)>,
-    {
-        let mut properties: Vec<(usize, Prop)> = Vec::new();
-        for (key, value) in self {
-            let value: Prop = value.into();
-            let prop_id = id_resolver(key.as_ref(), value.dtype())?;
-            properties.push((prop_id, value));
+    Ok(match input_time {
+        InputTime::Simple(t) => EventTime::new(t, graph.next_event_id().map_err(into_graph_err)?),
+        InputTime::Indexed(t, secondary_index) => {
+            let _ = graph
+                .set_max_event_id(secondary_index)
+                .map_err(into_graph_err)?;
+
+            EventTime::new(t, secondary_index)
         }
-        Ok(properties)
-    }
+    })
 }
diff --git a/raphtory/src/db/api/mutation/property_addition_ops.rs b/raphtory/src/db/api/mutation/property_addition_ops.rs
index bfb10d0a2c..e0c143ad0b 100644
--- a/raphtory/src/db/api/mutation/property_addition_ops.rs
+++ b/raphtory/src/db/api/mutation/property_addition_ops.rs
@@ -1,66 +1,186 @@
-use super::{time_from_input, CollectProperties};
-use crate::errors::{into_graph_err, GraphError};
-use raphtory_api::core::utils::time::TryIntoInputTime;
-use raphtory_storage::mutation::{
-    addition_ops::InternalAdditionOps, property_addition_ops::InternalPropertyAdditionOps,
+use crate::{
+    db::api::mutation::{time_from_input_session, TryIntoInputTime},
+    errors::{into_graph_err, GraphError},
 };
+use raphtory_api::core::entities::properties::prop::Prop;
+use raphtory_storage::{
+    core_ops::CoreGraphOps,
+    durability_ops::DurabilityOps,
+    mutation::{
+        addition_ops::InternalAdditionOps, property_addition_ops::InternalPropertyAdditionOps,
+    },
+};
+use storage::wal::{GraphWalOps, WalOps};
 
 pub trait PropertyAdditionOps:
     InternalPropertyAdditionOps<Error: Into<GraphError>> + InternalAdditionOps<Error: Into<GraphError>>
 {
-    fn add_properties<T: TryIntoInputTime, PI: CollectProperties>(
+    fn add_properties<
+        T: TryIntoInputTime,
+        PN: AsRef<str>,
+        PI: Into<Prop>,
+        PII: IntoIterator<Item = (PN, PI)>,
+    >(
         &self,
         t: T,
-        props: PI,
+        props: PII,
     ) -> Result<(), GraphError>;
 
-    fn add_metadata<PI: CollectProperties>(&self, props: PI) -> Result<(), GraphError>;
-    fn update_metadata<PI: CollectProperties>(&self, props: PI) -> Result<(), GraphError>;
+    fn add_metadata<PN: AsRef<str>, P: Into<Prop>, PII: IntoIterator<Item = (PN, P)>>(
+        &self,
+        props: PII,
+    ) -> Result<(), GraphError>;
+
+    fn update_metadata<PN: AsRef<str>, P: Into<Prop>, PII: IntoIterator<Item = (PN, P)>>(
+        &self,
+        props: PII,
+    ) -> Result<(), GraphError>;
 }
 
 impl<
         G: InternalPropertyAdditionOps<Error: Into<GraphError>>
-            + InternalAdditionOps<Error: Into<GraphError>>,
+            + InternalAdditionOps<Error: Into<GraphError>>
+            + CoreGraphOps,
     > PropertyAdditionOps for G
 {
-    fn add_properties<T: TryIntoInputTime, PI: CollectProperties>(
+    fn add_properties<
+        T: TryIntoInputTime,
+        PN: AsRef<str>,
+        PI: Into<Prop>,
+        PII: IntoIterator<Item = (PN, PI)>,
+    >(
         &self,
         t: T,
-        props: PI,
+        props: PII,
     ) -> Result<(), GraphError> {
-        let ti = time_from_input(self, t)?;
-        let properties: Vec<_> = props.collect_properties(|name, dtype| {
-            Ok(self
-                .resolve_graph_property(name, dtype, false)
-                .map_err(into_graph_err)?
-                .inner())
-        })?;
-        self.internal_add_properties(ti, &properties)
+        let transaction_manager = self.core_graph().transaction_manager()?;
+        let wal = self.core_graph().wal()?;
+        let transaction_id = transaction_manager.begin_transaction();
+        let session = self.write_session().map_err(|err| err.into())?;
+        let t = time_from_input_session(&session, t)?;
+
+        let props_with_status = self
+            .validate_props_with_status(
+                false,
+                self.graph_props_meta(),
+                props.into_iter().map(|(k, v)| (k, v.into())),
+            )
             .map_err(into_graph_err)?;
-        Ok(())
-    }
 
-    fn add_metadata<PI: CollectProperties>(&self, props: PI) -> Result<(), GraphError> {
-        let properties: Vec<_> = props.collect_properties(|name, dtype| {
-            Ok(self
-                .resolve_graph_property(name, dtype, true)
-                .map_err(into_graph_err)?
-                .inner())
-        })?;
-        self.internal_add_metadata(&properties)
+        let props = props_with_status
+            .iter()
+            .map(|maybe_new| {
+                let (_, prop_id, prop) = maybe_new.as_ref().inner();
+                (*prop_id, prop.clone())
+            })
+            .collect::<Vec<_>>();
+
+        let mut writer = self
+            .internal_add_properties(t, &props)
             .map_err(into_graph_err)?;
-        Ok(())
-    }
 
-    fn update_metadata<PI: CollectProperties>(&self, props: PI) -> Result<(), GraphError> {
-        let properties: Vec<_> = props.collect_properties(|name, dtype| {
-            Ok(self
-                .resolve_graph_property(name, dtype, true)
-                .map_err(into_graph_err)?
-                .inner())
-        })?;
-        self.internal_update_metadata(&properties)
+        let props_for_wal = props_with_status
+            .iter()
+            .map(|maybe_new| {
+                let (prop_name, prop_id, prop) = maybe_new.as_ref().inner();
+                (prop_name.as_ref(), *prop_id, prop.clone())
+            })
+            .collect::<Vec<_>>();
+
+        let lsn = wal
+            .log_add_graph_props(transaction_id, t, props_for_wal)
             .map_err(into_graph_err)?;
+
+        writer.set_lsn(lsn);
+        transaction_manager.end_transaction(transaction_id);
+        drop(writer);
+
+        if let Err(e) = wal.flush(lsn) {
+            return Err(GraphError::FatalWriteError(e));
+        }
+
         Ok(())
     }
+
+    fn add_metadata<PN: AsRef<str>, P: Into<Prop>, PII: IntoIterator<Item = (PN, P)>>(
+        &self,
+        props: PII,
+    ) -> Result<(), GraphError> {
+        let is_update = false;
+        add_metadata_impl(self, props, is_update)
+    }
+
+    fn update_metadata<PN: AsRef<str>, P: Into<Prop>, PII: IntoIterator<Item = (PN, P)>>(
+        &self,
+        props: PII,
+    ) -> Result<(), GraphError> {
+        let is_update = true;
+        add_metadata_impl(self, props, is_update)
+    }
+}
+
+fn add_metadata_impl<G, PN, P, PII>(
+    graph: &G,
+    props: PII,
+    is_update: bool,
+) -> Result<(), GraphError>
+where
+    G: InternalPropertyAdditionOps<Error: Into<GraphError>>
+        + InternalAdditionOps<Error: Into<GraphError>>
+        + CoreGraphOps,
+    PN: AsRef<str>,
+    P: Into<Prop>,
+    PII: IntoIterator<Item = (PN, P)>,
+{
+    let transaction_manager = graph.core_graph().transaction_manager()?;
+    let wal = graph.core_graph().wal()?;
+    let transaction_id = transaction_manager.begin_transaction();
+
+    let props_with_status = graph
+        .validate_props_with_status(
+            true,
+            graph.graph_props_meta(),
+            props.into_iter().map(|(k, v)| (k, v.into())),
+        )
+        .map_err(into_graph_err)?;
+
+    let props = props_with_status
+        .iter()
+        .map(|maybe_new| {
+            let (_, prop_id, prop) = maybe_new.as_ref().inner();
+            (*prop_id, prop.clone())
+        })
+        .collect::<Vec<_>>();
+
+    let mut writer = if is_update {
+        graph
+            .internal_update_metadata(&props)
+            .map_err(into_graph_err)?
+    } else {
+        graph
+            .internal_add_metadata(&props)
+            .map_err(into_graph_err)?
+    };
+
+    let props_for_wal = props_with_status
+        .iter()
+        .map(|maybe_new| {
+            let (prop_name, prop_id, prop) = maybe_new.as_ref().inner();
+            (prop_name.as_ref(), *prop_id, prop.clone())
+        })
+        .collect::<Vec<_>>();
+
+    let lsn = wal
+        .log_add_graph_metadata(transaction_id, props_for_wal)
+        .map_err(into_graph_err)?;
+
+    writer.set_lsn(lsn);
+    transaction_manager.end_transaction(transaction_id);
+    drop(writer);
+
+    if let Err(e) = wal.flush(lsn) {
+        return Err(GraphError::FatalWriteError(e));
+    }
+
+    Ok(())
 }
diff --git a/raphtory/src/db/api/properties/internal.rs b/raphtory/src/db/api/properties/internal.rs
index 68ccc855e5..7fbaa6a382 100644
--- a/raphtory/src/db/api/properties/internal.rs
+++ b/raphtory/src/db/api/properties/internal.rs
@@ -10,7 +10,6 @@ use raphtory_api::{
 
 pub trait InternalTemporalPropertyViewOps {
     fn dtype(&self, id: usize) -> PropType;
-    fn temporal_value(&self, id: usize) -> Option<Prop>;
 
     fn temporal_iter(&self, id: usize) -> BoxedLIter<'_, (EventTime, Prop)>;
 
@@ -23,6 +22,9 @@ pub trait InternalTemporalPropertyViewOps {
         self.temporal_iter_rev(id).map(|(t, _)| t).into_dyn_boxed()
     }
 
+    /// Return the latest temporal prop value.
+    fn temporal_value(&self, id: usize) -> Option<Prop>;
+
     fn temporal_values_iter(&self, id: usize) -> BoxedLIter<'_, Prop> {
         self.temporal_iter(id).map(|(_, v)| v).into_dyn_boxed()
     }
@@ -41,14 +43,19 @@ pub trait TemporalPropertiesRowView {
 pub trait InternalMetadataOps: Send + Sync {
     /// Find id for property name (note this only checks the meta-data, not if the property actually exists for the entity)
     fn get_metadata_id(&self, name: &str) -> Option<usize>;
+
     fn get_metadata_name(&self, id: usize) -> ArcStr;
+
     fn metadata_ids(&self) -> BoxedLIter<'_, usize>;
+
     fn metadata_keys(&self) -> BoxedLIter<'_, ArcStr> {
         Box::new(self.metadata_ids().map(|id| self.get_metadata_name(id)))
     }
+
     fn metadata_values(&self) -> BoxedLIter<'_, Option<Prop>> {
         Box::new(self.metadata_ids().map(|k| self.get_metadata(k)))
     }
+
     fn get_metadata(&self, id: usize) -> Option<Prop>;
 }
 
diff --git a/raphtory/src/db/api/properties/temporal_props.rs b/raphtory/src/db/api/properties/temporal_props.rs
index 5111e687d3..ff000a9a5f 100644
--- a/raphtory/src/db/api/properties/temporal_props.rs
+++ b/raphtory/src/db/api/properties/temporal_props.rs
@@ -1,7 +1,7 @@
 use bigdecimal::BigDecimal;
 use chrono::NaiveDateTime;
 use raphtory_api::core::{
-    entities::properties::prop::{Prop, PropType, PropUnwrap},
+    entities::properties::prop::{Prop, PropArray, PropType, PropUnwrap},
     storage::{arc_str::ArcStr, timeindex::EventTime},
 };
 use rustc_hash::FxHashMap;
@@ -12,13 +12,15 @@ use std::{
     sync::Arc,
 };
 
-use crate::db::api::{
-    properties::internal::InternalPropertiesOps,
-    view::{history::History, BoxedLIter},
+use crate::db::api::{properties::internal::InternalPropertiesOps, view::history::History};
+use arrow::array::ArrayRef;
+use raphtory_api::{
+    core::{
+        entities::properties::prop::PropArrayUnwrap, storage::timeindex::AsTime,
+        utils::time::IntoTime,
+    },
+    iter::BoxedLIter,
 };
-use raphtory_api::core::{storage::timeindex::AsTime, utils::time::IntoTime};
-#[cfg(feature = "arrow")]
-use {arrow::array::ArrayRef, raphtory_api::core::entities::properties::prop::PropArrayUnwrap};
 
 #[derive(Clone)]
 pub struct TemporalPropertyView<P: InternalPropertiesOps> {
@@ -89,7 +91,7 @@ impl<P: InternalPropertiesOps + Clone> TemporalPropertyView<P> {
     }
 
     pub fn iter_rev(&self) -> impl Iterator<Item = (EventTime, Prop)> + '_ {
-        self.history().reverse().into_iter().zip(self.values_rev())
+        self.history().into_iter_rev().zip(self.values_rev())
     }
 
     pub fn iter_indexed(&self) -> impl Iterator<Item = (EventTime, Prop)> + use<'_, P> {
@@ -113,6 +115,79 @@ impl<P: InternalPropertiesOps + Clone> TemporalPropertyView<P> {
         unique_props.into_iter().collect()
     }
 
+    /// Compute the sum of all property values, or `None` if the dtype is not additive or the
+    /// property is empty.
+    pub fn sum(&self) -> Option<Prop> {
+        generalised_reduce(self.values(), |a, b| a.add(b), |p| p.dtype().has_add())
+    }
+
+    /// Find the minimum `(time, value)` pair, or `None` if the dtype is not comparable or the
+    /// property is empty.
+    pub fn min(&self) -> Option<(EventTime, Prop)> {
+        generalised_reduce(
+            self.iter(),
+            |a, b| {
+                if a.1.partial_cmp(&b.1)?.is_le() {
+                    Some(a)
+                } else {
+                    Some(b)
+                }
+            },
+            |(_, v)| v.dtype().has_cmp(),
+        )
+    }
+
+    /// Find the maximum `(time, value)` pair, or `None` if the dtype is not comparable or the
+    /// property is empty.
+    pub fn max(&self) -> Option<(EventTime, Prop)> {
+        generalised_reduce(
+            self.iter(),
+            |a, b| {
+                if a.1.partial_cmp(&b.1)?.is_ge() {
+                    Some(a)
+                } else {
+                    Some(b)
+                }
+            },
+            |(_, v)| v.dtype().has_cmp(),
+        )
+    }
+
+    /// Count the number of property updates.
+    pub fn count(&self) -> usize {
+        self.iter().count()
+    }
+
+    /// Compute the mean of all property values as an `F64` Prop, or `None` if any value cannot be
+    /// converted to `f64` or the property is empty.
+    pub fn mean(&self) -> Option<Prop> {
+        let mut iter = self.values();
+        let mut sum = iter.next()?.as_f64()?;
+        let mut count = 1usize;
+        for value in iter {
+            sum += value.as_f64()?;
+            count += 1;
+        }
+        Some(Prop::F64(sum / count as f64))
+    }
+
+    /// Alias for `mean`.
+    pub fn average(&self) -> Option<Prop> {
+        self.mean()
+    }
+
+    /// Compute the median `(time, value)` pair (lower median on even-length inputs), or `None` if
+    /// the dtype is not comparable or the property is empty.
+    pub fn median(&self) -> Option<(EventTime, Prop)> {
+        let mut sorted: Vec<(EventTime, Prop)> = self.iter().collect();
+        if !sorted.first()?.1.dtype().has_cmp() {
+            return None;
+        }
+        sorted.sort_by(|a, b| a.1.partial_cmp(&b.1).unwrap_or(std::cmp::Ordering::Equal));
+        let len = sorted.len();
+        Some(sorted.swap_remove((len - 1) / 2))
+    }
+
     pub fn ordered_dedupe(&self, latest_time: bool) -> Vec<(EventTime, Prop)> {
         let mut last_seen_value: Option<Prop> = None;
         let mut result: Vec<(EventTime, Prop)> = vec![];
@@ -282,7 +357,7 @@ impl<P: InternalPropertiesOps + Clone> PropUnwrap for TemporalPropertyView<P> {
         self.latest().into_bool()
     }
 
-    fn into_list(self) -> Option<Arc<Vec<Prop>>> {
+    fn into_list(self) -> Option<PropArray> {
         self.latest().into_list()
     }
 
@@ -303,9 +378,21 @@ impl<P: InternalPropertiesOps + Clone> PropUnwrap for TemporalPropertyView<P> {
     }
 }
 
-#[cfg(feature = "arrow")]
 impl<P: InternalPropertiesOps + Clone> PropArrayUnwrap for TemporalPropertyView<P> {
     fn into_array(self) -> Option<ArrayRef> {
         self.latest().into_array()
     }
 }
+
+fn generalised_reduce<V>(
+    data: impl IntoIterator<Item = V>,
+    op: impl Fn(V, V) -> Option<V>,
+    check: impl Fn(&V) -> bool,
+) -> Option<V> {
+    let mut iter = data.into_iter();
+    let first = iter.next()?;
+    if !check(&first) {
+        return None;
+    }
+    iter.try_fold(first, op)
+}
diff --git a/raphtory/src/db/api/state/generic_node_state.rs b/raphtory/src/db/api/state/generic_node_state.rs
index f49f5dcb08..6b01686e75 100644
--- a/raphtory/src/db/api/state/generic_node_state.rs
+++ b/raphtory/src/db/api/state/generic_node_state.rs
@@ -2,51 +2,63 @@ use crate::{
     core::entities::{nodes::node_ref::AsNodeRef, VID},
     db::{
         api::{
-            state::{node_state_ops::NodeStateOps, ops::Const, Index},
-            view::{DynamicGraph, IntoDynBoxed, IntoDynamic},
+            state::{
+                node_state_ops::NodeStateOps,
+                ops::{filter::NO_FILTER, Const},
+                Index,
+            },
+            view::{
+                internal::GraphView, BoxableGraphView, DynamicGraph, IntoDynBoxed, IntoDynamic,
+            },
+        },
+        graph::{
+            node::NodeView, nodes::Nodes,
+            views::filter::model::node_state_filter::NodeStateBoolColOp,
         },
-        graph::{node::NodeView, nodes::Nodes},
     },
     errors::GraphError,
     prelude::{GraphViewOps, NodeViewOps},
 };
-
 use arrow::{
     array::AsArray,
     compute::{cast_with_options, interleave_record_batch, CastOptions},
     datatypes::UInt64Type,
     row::{RowConverter, SortField},
 };
-use arrow_array::{Array, ArrayRef, RecordBatch, StringArray, UInt32Array};
+use arrow_array::{
+    builder::UInt64Builder, Array, ArrayRef, RecordBatch, StringArray, UInt32Array, UInt64Array,
+};
 use arrow_schema::{ArrowError, DataType, Field, FieldRef, Schema, SchemaBuilder, SortOptions};
+use arrow_select::{concat::concat, take::take};
 use dashmap::DashMap;
+use datafusion_expr_common::groups_accumulator::EmitTo;
+use datafusion_physical_expr::expressions::col;
+use datafusion_physical_expr_common::sort_expr::PhysicalSortExpr;
+use datafusion_physical_plan::aggregates::{group_values::new_group_values, order::GroupOrdering};
 use indexmap::{IndexMap, IndexSet};
 use parquet::{
     arrow::{arrow_reader::ParquetRecordBatchReaderBuilder, ArrowWriter},
     basic::Compression,
     file::properties::WriterProperties,
 };
-
-use arrow_array::{builder::UInt64Builder, UInt64Array};
-use arrow_select::{concat::concat, take::take};
-use datafusion_expr_common::groups_accumulator::EmitTo;
-use datafusion_physical_expr::expressions::col;
-use datafusion_physical_expr_common::sort_expr::PhysicalSortExpr;
-use datafusion_physical_plan::aggregates::{group_values::new_group_values, order::GroupOrdering};
-use raphtory_api::core::entities::properties::prop::{Prop, PropType, PropUntagged, PropUnwrap};
-use rayon::{iter::Either, prelude::*};
+use raphtory_api::core::entities::{
+    properties::{
+        meta::STATIC_GRAPH_LAYER_ID,
+        prop::{Prop, PropType, PropUntagged, PropUnwrap},
+    },
+    LayerIds,
+};
+use rayon::prelude::*;
 use serde::{de::DeserializeOwned, Serialize};
 use serde_arrow::{
     from_record_batch,
     schema::{SchemaLike, TracingOptions},
     to_record_batch, Deserializer,
 };
-
-use crate::db::graph::views::filter::model::node_state_filter::NodeStateBoolColOp;
 use std::{
     cmp::{Ordering, PartialEq},
     collections::{BinaryHeap, HashMap},
-    fmt::{Debug, Formatter},
+    fmt::{Debug, Formatter, Pointer},
     fs::File,
     hash::BuildHasher,
     marker::PhantomData,
@@ -114,8 +126,12 @@ where
 pub type TransformedPropMap<'graph, G> = IndexMap<String, NodeStateOutput<'graph, G>>;
 
 // Shorthand for a TypedNodeState which is ideal for usage in Python.
-pub type OutputTypedNodeState<'graph, G> =
-    TypedNodeState<'graph, PropMap, G, TransformedPropMap<'graph, G>>;
+pub type OutputTypedNodeState<'graph, G> = TypedNodeState<
+    'graph,
+    PropMap,
+    G,
+    TransformedPropMap<'graph, Arc<dyn BoxableGraphView + 'graph>>,
+>;
 
 pub trait NodeTransform {
     type Input;
@@ -173,17 +189,38 @@ impl Ord for HeapRow {
     }
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 pub struct GenericNodeState<'graph, G> {
     pub base_graph: G,
     values: RecordBatch,
-    pub(crate) keys: Option<Index<VID>>,
+    pub(crate) keys: Index<VID>,
     // Data structure mapping which columns are node-containing and, if so, which graph they belong to
     // note: maybe change that Option<G> to a Option<Box<dyn GraphViewOps>> or something
-    pub node_cols: HashMap<String, (NodeStateOutputType, Option<G>)>,
+    pub node_cols: HashMap<
+        String,
+        (
+            NodeStateOutputType,
+            Option<Arc<dyn BoxableGraphView + 'graph>>,
+        ),
+    >,
     _marker: PhantomData<&'graph ()>,
 }
 
+impl<'graph, G: Debug + 'graph> Debug for GenericNodeState<'graph, G> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let node_cols: HashMap<_, _> = self
+            .node_cols
+            .iter()
+            .map(|(col_name, (node_type, _))| (col_name, node_type))
+            .collect();
+        f.debug_struct("GenericNodeState")
+            .field("base_graph", &self.base_graph)
+            .field("values", &self.values)
+            .field("node_cols", &node_cols)
+            .finish()
+    }
+}
+
 impl<'graph, G> GenericNodeState<'graph, G> {
     #[inline]
     pub fn values_ref(&self) -> &RecordBatch {
@@ -191,8 +228,8 @@ impl<'graph, G> GenericNodeState<'graph, G> {
     }
 
     #[inline]
-    pub fn keys_ref(&self) -> Option<&Index<VID>> {
-        self.keys.as_ref()
+    pub fn keys_ref(&self) -> &Index<VID> {
+        &self.keys
     }
 }
 
@@ -252,19 +289,13 @@ where
     }
 }
 
-impl<'graph, G: IntoDynamic> GenericNodeState<'graph, G> {
-    pub fn into_dyn(self) -> GenericNodeState<'graph, DynamicGraph> {
-        let node_cols = Some(
-            self.node_cols
-                .into_iter()
-                .map(|(k, (output_type, bg))| (k, (output_type, bg.map(|bg| bg.into_dynamic()))))
-                .collect(),
-        );
+impl<G: IntoDynamic> GenericNodeState<'static, G> {
+    pub fn into_dyn(self) -> GenericNodeState<'static, DynamicGraph> {
         GenericNodeState::new(
             self.base_graph.into_dynamic(),
             self.values,
             self.keys,
-            node_cols,
+            Some(self.node_cols),
         )
     }
 }
@@ -273,8 +304,16 @@ impl<'graph, G: GraphViewOps<'graph>> GenericNodeState<'graph, G> {
     pub fn new(
         base_graph: G,
         values: RecordBatch,
-        keys: Option<Index<VID>>,
-        node_cols: Option<HashMap<String, (NodeStateOutputType, Option<G>)>>,
+        keys: Index<VID>,
+        node_cols: Option<
+            HashMap<
+                String,
+                (
+                    NodeStateOutputType,
+                    Option<Arc<dyn BoxableGraphView + 'graph>>,
+                ),
+            >,
+        >,
     ) -> Self {
         Self {
             base_graph,
@@ -291,79 +330,53 @@ impl<'graph, G: GraphViewOps<'graph>> GenericNodeState<'graph, G> {
     pub fn get_nodes(
         state: &GenericNodeState<'graph, G>,
         value_map: PropMap,
-    ) -> TransformedPropMap<'graph, G> {
+    ) -> TransformedPropMap<'graph, Arc<dyn BoxableGraphView + 'graph>> {
         // for column in aux data structure
         value_map
             .into_iter()
             .map(|(key, value)| {
-                let node_col_entry = state.node_cols.get(&key);
-                let mut result = None;
-                if value.is_none() || node_col_entry.is_none() {
-                    return (key, NodeStateOutput::Prop(value));
-                } else {
-                    let (node_state_type, base_graph) = node_col_entry.unwrap();
-                    if node_state_type == &NodeStateOutputType::Node {
-                        if let Some(PropUntagged(Prop::U64(vid))) = value {
-                            result = Some((
-                                key,
-                                NodeStateOutput::Node(NodeView::new_internal(
-                                    base_graph.as_ref().unwrap_or(&state.base_graph).clone(),
-                                    VID(vid as usize),
-                                )),
-                            ));
-                        }
-                    } else if node_state_type == &NodeStateOutputType::Nodes {
-                        #[cfg(feature = "arrow")]
-                        if let Some(PropUntagged(Prop::Array(vid_arr))) = value {
-                            return (
-                                key,
-                                NodeStateOutput::Nodes(Nodes::new_filtered(
-                                    base_graph.as_ref().unwrap_or(&state.base_graph).clone(),
-                                    base_graph.as_ref().unwrap_or(&state.base_graph).clone(),
-                                    Const(true),
-                                    Some(Index::from_iter(
-                                        vid_arr
-                                            .iter_prop()
-                                            .map(|vid| VID(vid.into_u64().unwrap() as usize)),
-                                    )),
-                                )),
-                            );
-                        }
-
-                        if let Some(PropType::List(_)) = value.as_ref().map(|value| value.0.dtype())
-                        {
-                            if let Some(PropUntagged(Prop::List(vid_list))) = value {
-                                if let Some(vid_list) = Arc::into_inner(vid_list) {
-                                    result = Some((
-                                        key,
-                                        NodeStateOutput::Nodes(Nodes::new_filtered(
-                                            base_graph
-                                                .as_ref()
-                                                .unwrap_or(&state.base_graph)
-                                                .clone(),
-                                            base_graph
-                                                .as_ref()
-                                                .unwrap_or(&state.base_graph)
-                                                .clone(),
-                                            Const(true),
-                                            Some(Index::from_iter(vid_list.into_iter().map(
-                                                |vid| {
-                                                    VID(vid
-                                                        .try_cast(PropType::U64)
-                                                        .unwrap()
-                                                        .into_u64()
-                                                        .unwrap()
-                                                        as usize)
-                                                },
-                                            ))),
-                                        )),
-                                    ));
-                                }
-                            }
-                        }
+                let value = match value {
+                    None => return (key, NodeStateOutput::Prop(value)),
+                    Some(v) => v,
+                };
+                let (node_state_type, base_graph) = match state.node_cols.get(&key) {
+                    None => return (key, NodeStateOutput::Prop(Some(value))),
+                    Some(v) => v,
+                };
+                match node_state_type {
+                    NodeStateOutputType::Node => {
+                        let vid = value.0.unwrap_u64();
+                        (
+                            key,
+                            NodeStateOutput::Node(NodeView::new_internal(
+                                base_graph
+                                    .clone()
+                                    .unwrap_or(Arc::new(state.base_graph.clone())),
+                                VID(vid as usize),
+                            )),
+                        )
+                    }
+                    NodeStateOutputType::Nodes => {
+                        let nodes = value.0.unwrap_list();
+                        let base_graph = base_graph
+                            .clone()
+                            .unwrap_or(Arc::new(state.base_graph.clone()));
+                        let index: Index<_> = nodes
+                            .iter()
+                            .map(|prop| VID(prop.cast_num().unwrap()))
+                            .collect();
+                        (
+                            key,
+                            NodeStateOutput::Nodes(Nodes::new_filtered(
+                                base_graph.clone(),
+                                base_graph,
+                                Const(true),
+                                index,
+                            )),
+                        )
                     }
+                    NodeStateOutputType::Prop => (key, NodeStateOutput::Prop(Some(value))),
                 }
-                result.unwrap()
             })
             .collect()
     }
@@ -373,7 +386,7 @@ impl<'graph, G: GraphViewOps<'graph>> GenericNodeState<'graph, G> {
         TypedNodeState::new_mapped(self, Self::get_nodes)
     }
 
-    pub fn into_inner(self) -> (RecordBatch, Option<Index<VID>>) {
+    pub fn into_inner(self) -> (RecordBatch, Index<VID>) {
         (self.values, self.keys)
     }
 
@@ -383,17 +396,14 @@ impl<'graph, G: GraphViewOps<'graph>> GenericNodeState<'graph, G> {
 
     fn get_index_by_node<N: AsNodeRef>(&self, node: &N) -> Option<usize> {
         let id = self.base_graph.internalise_node(node.as_node_ref())?;
-        match &self.keys {
-            Some(index) => index.index(&id),
-            None => Some(id.0),
-        }
+        self.keys.index(&id)
     }
 
     fn nodes(&self) -> Nodes<'graph, G> {
         Nodes::new_filtered(
             self.base_graph.clone(),
             self.base_graph.clone(),
-            Const(true),
+            NO_FILTER,
             self.keys.clone(),
         )
     }
@@ -408,7 +418,9 @@ impl<'graph, G: GraphViewOps<'graph>> GenericNodeState<'graph, G> {
         // If ID column is specified and exists, try to construct index using that column
         id_column: Option<String>,
     ) -> Result<GenericNodeState<'graph, G>, GraphError> {
-        let num_nodes = self.base_graph.unfiltered_num_nodes();
+        let num_nodes = self
+            .base_graph
+            .unfiltered_num_nodes(&LayerIds::One(STATIC_GRAPH_LAYER_ID));
         let file = File::open(file_path)?;
         let builder = ParquetRecordBatchReaderBuilder::try_new(file)
             .map_err(|e| GraphError::IOErrorMsg(e.to_string()))?;
@@ -467,9 +479,7 @@ impl<'graph, G: GraphViewOps<'graph>> GenericNodeState<'graph, G> {
                         .to_string(),
                     ));
                 }
-                index = Some(Index::from_iter(
-                    arr.iter().map(|v| VID(v.unwrap_or(0) as usize)),
-                ));
+                index = Index::from_iter(arr.iter().map(|v| VID(v.unwrap_or(0) as usize)));
             } else {
                 return Err(GraphError::IOErrorMsg(
                     format!("Column {} is not unsigned integer type.", col_name).to_string(),
@@ -477,7 +487,7 @@ impl<'graph, G: GraphViewOps<'graph>> GenericNodeState<'graph, G> {
             }
             batch.remove_column(schema.column_with_name(col_name).unwrap().0);
         } else if batch.num_rows() < num_nodes {
-            index = Some(Index::from_iter((0..batch.num_rows()).map(VID)));
+            index = Index::from_iter((0..batch.num_rows()).map(VID));
         }
 
         Ok(GenericNodeState {
@@ -533,20 +543,16 @@ impl<'graph, G: GraphViewOps<'graph>> GenericNodeState<'graph, G> {
     // Auxiliary function to merge columns of merging GenericNodeStates
     fn merge_columns(
         col_name: &String,
-        tgt_idx_set: Option<&Index<VID>>, // index set of the merged GenricNodeState
+        tgt_idx_set: &Index<VID>, // index set of the merged GenricNodeState
         tgt_idx_set_len: usize,
-        lh: Option<&Index<VID>>,
-        rh: Option<&Index<VID>>,
+        lh: &Index<VID>,
+        rh: &Index<VID>,
         lh_batch: &RecordBatch,
         rh_batch: &RecordBatch,
     ) -> (Arc<dyn Array>, Field) {
         // clever tricks with take array_select::take to work with generic columns
         // need to construct a 'take index' to figure out which values we're grabbing
-        let iter = if tgt_idx_set.is_some() {
-            Either::Left(tgt_idx_set.as_ref().unwrap().iter())
-        } else {
-            Either::Right((0..tgt_idx_set_len).map(VID))
-        };
+        let iter = tgt_idx_set.iter();
         let mut idx_builder = UInt64Builder::with_capacity(tgt_idx_set_len);
         let left_col = lh_batch.column_by_name(col_name);
         let left_len = if left_col.is_some() {
@@ -561,78 +567,55 @@ impl<'graph, G: GraphViewOps<'graph>> GenericNodeState<'graph, G> {
             (None, Some(r)) => r,
             (None, None) => unreachable!("at least one is guaranteed to be Some"),
         };
+
         for i in iter {
-            if left_col.is_some() && (lh.is_none() || lh.unwrap().contains(&i)) {
-                if lh.is_none() {
-                    idx_builder.append_value(i.0 as u64);
-                } else {
-                    idx_builder.append_value(lh.unwrap().index(&i).unwrap() as u64);
+            if left_col.is_some() {
+                if let Some(idx) = lh.index(&i) {
+                    idx_builder.append_value(idx as u64);
+                    continue;
                 }
-            } else if right_col.is_some() && (rh.is_none() || rh.unwrap().contains(&i)) {
-                if rh.is_none() {
-                    idx_builder.append_value((left_len + i.0) as u64);
-                } else {
-                    idx_builder.append_value((left_len + rh.unwrap().index(&i).unwrap()) as u64);
+            }
+            if right_col.is_some() {
+                if let Some(idx) = rh.index(&i) {
+                    idx_builder.append_value((left_len + idx) as u64);
+                    continue;
                 }
-            } else {
-                idx_builder.append_null();
             }
+            idx_builder.append_null()
         }
         let take_idx: UInt64Array = idx_builder.finish();
-        let mut field = lh_batch.schema_ref().field_with_name(col_name);
-        if field.is_err() {
-            field = rh_batch.schema_ref().field_with_name(col_name);
-        }
-        (
-            take(cat.as_ref(), &take_idx, None).unwrap(),
-            field.unwrap().clone(),
-        )
+        let field = lh_batch
+            .schema_ref()
+            .field_with_name(col_name)
+            .or_else(|_| rh_batch.schema_ref().field_with_name(col_name))
+            .expect("field should exist in at least one of the batches");
+        (take(cat.as_ref(), &take_idx, None).unwrap(), field.clone())
     }
 
     // Merge with another GenericNodeState. Produces a new GenericNodeState.
     // Options for merging index sets are exclusively use left or right, or to union the sets
     // Options for merging columns are to prioritize left or right, or exclude the column
-    pub fn merge(
+    pub fn merge<G2: GraphView + 'graph>(
         &self,
-        other: &GenericNodeState<'graph, G>,
+        other: &GenericNodeState<'graph, G2>,
         index_merge_priority: MergePriority, // Exclude = Union of index sets
         default_column_merge_priority: MergePriority,
         column_merge_priority_map: Option<HashMap<String, MergePriority>>,
     ) -> Self {
         // if any columns contain nodes, you need to preserve that information in the node_cols structure
-        let mut merge_node_cols: HashMap<String, (NodeStateOutputType, Option<G>)> =
-            HashMap::default();
-        let default_node_cols: &HashMap<String, (NodeStateOutputType, Option<G>)> =
-            if default_column_merge_priority == MergePriority::Left {
-                &self.node_cols
-            } else {
-                &other.node_cols
-            };
-
-        // handle index set merging
-        let new_idx_set = if self.keys.is_none() || other.keys.is_none() {
-            None
+        let mut merge_node_cols = HashMap::default();
+        let default_node_cols = if default_column_merge_priority == MergePriority::Left {
+            &self.node_cols
         } else {
-            Some(
-                IndexSet::union(
-                    self.keys.as_ref().unwrap().index.as_ref(),
-                    other.keys.as_ref().unwrap().index.as_ref(),
-                )
-                .clone()
-                .into_iter()
-                .map(|v| v.to_owned())
-                .collect(),
-            )
+            &other.node_cols
         };
+
         let tgt_idx_set = match index_merge_priority {
-            MergePriority::Left => self.keys.as_ref(),
-            MergePriority::Right => other.keys.as_ref(),
-            MergePriority::Exclude => new_idx_set.as_ref(),
+            MergePriority::Left => self.keys_ref().clone(),
+            MergePriority::Right => other.keys_ref().clone(),
+            MergePriority::Exclude => self.keys_ref().union(other.keys_ref()),
         };
-        let tgt_index_set_len = tgt_idx_set
-            .map_or(self.base_graph.unfiltered_num_nodes(), |idx_set| {
-                idx_set.len()
-            });
+        let tgt_index_set_len = tgt_idx_set.len();
 
         let mut cols: Vec<Arc<dyn Array>> = vec![];
         let mut fields: Vec<Field> = vec![];
@@ -649,8 +632,8 @@ impl<'graph, G: GraphViewOps<'graph>> GenericNodeState<'graph, G> {
                             );
                         }
                         (
-                            self.keys.as_ref(),
-                            other.keys.as_ref(),
+                            self.keys_ref(),
+                            other.keys_ref(),
                             &self.values,
                             &other.values,
                         )
@@ -663,8 +646,8 @@ impl<'graph, G: GraphViewOps<'graph>> GenericNodeState<'graph, G> {
                             );
                         }
                         (
-                            other.keys.as_ref(),
-                            self.keys.as_ref(),
+                            other.keys_ref(),
+                            self.keys_ref(),
                             &other.values,
                             &self.values,
                         )
@@ -673,7 +656,7 @@ impl<'graph, G: GraphViewOps<'graph>> GenericNodeState<'graph, G> {
                 };
                 let (col, field) = GenericNodeState::<'graph, G>::merge_columns(
                     col_name,
-                    tgt_idx_set,
+                    &tgt_idx_set,
                     tgt_index_set_len,
                     lh,
                     rh,
@@ -689,14 +672,14 @@ impl<'graph, G: GraphViewOps<'graph>> GenericNodeState<'graph, G> {
         // merge remaining columns accordingly
         let (lh, rh, lh_batch, rh_batch) = match default_column_merge_priority {
             MergePriority::Left => (
-                self.keys.as_ref(),
-                other.keys.as_ref(),
+                self.keys_ref(),
+                other.keys_ref(),
                 &self.values,
                 &other.values,
             ),
             MergePriority::Right => (
-                other.keys.as_ref(),
-                self.keys.as_ref(),
+                other.keys_ref(),
+                self.keys_ref(),
                 &other.values,
                 &self.values,
             ),
@@ -704,7 +687,7 @@ impl<'graph, G: GraphViewOps<'graph>> GenericNodeState<'graph, G> {
                 return GenericNodeState::new(
                     self.base_graph.clone(),
                     RecordBatch::try_new(Schema::new(fields).into(), cols).unwrap(),
-                    tgt_idx_set.cloned(),
+                    tgt_idx_set,
                     Some(merge_node_cols),
                 );
             }
@@ -724,7 +707,7 @@ impl<'graph, G: GraphViewOps<'graph>> GenericNodeState<'graph, G> {
                 }
                 let (col, field) = GenericNodeState::<'graph, G>::merge_columns(
                     col_name,
-                    tgt_idx_set,
+                    &tgt_idx_set,
                     tgt_index_set_len,
                     lh,
                     rh,
@@ -738,7 +721,7 @@ impl<'graph, G: GraphViewOps<'graph>> GenericNodeState<'graph, G> {
         GenericNodeState::new(
             self.base_graph.clone(),
             RecordBatch::try_new(Schema::new(fields).into(), cols).unwrap(),
-            tgt_idx_set.cloned(),
+            tgt_idx_set,
             Some(merge_node_cols),
         )
     }
@@ -893,9 +876,7 @@ impl<
             .into_par_iter()
             .enumerate()
             .for_each(|(node_idx, group_value_idx)| {
-                let vid = self.state.keys.as_ref().map_or(VID(node_idx), |idx| {
-                    idx.index.get_index(node_idx).unwrap().clone()
-                });
+                let vid = self.state.keys_ref().value(node_idx).unwrap();
                 groups.entry(group_value_idx).or_default().insert(vid);
             });
 
@@ -908,13 +889,12 @@ impl<
                         self.graph().clone(),
                         self.graph().clone(),
                         Const(true),
-                        Some(Index::new(nodes)),
+                        Index::new(nodes),
                     ),
                 )
             })
             .collect();
-
-        return Ok(result);
+        Ok(result)
     }
 }
 
@@ -973,12 +953,15 @@ impl<
         'graph,
         K: AsNodeRef,
         RHS: NodeStateValue + 'graph,
+        V,
         T: Clone + Send + Sync + 'graph,
         G: GraphViewOps<'graph>,
         S,
-    > PartialEq<HashMap<K, RHS, S>> for TypedNodeState<'graph, RHS, G, T>
+    > PartialEq<HashMap<K, V, S>> for TypedNodeState<'graph, RHS, G, T>
+where
+    RHS: PartialEq<V>,
 {
-    fn eq(&self, other: &HashMap<K, RHS, S>) -> bool {
+    fn eq(&self, other: &HashMap<K, V, S>) -> bool {
         other.len() == self.len()
             && other
                 .iter()
@@ -1020,7 +1003,7 @@ impl<'graph, G: GraphViewOps<'graph>> OutputTypedNodeState<'graph, G> {
 
                 let casted_rhs = rhs_val
                     .try_cast(lhs_val.0.dtype())
-                    .map_err(|_| "Failed to cast rhs value")?;
+                    .ok_or("Failed to cast rhs value")?;
 
                 if casted_rhs != lhs_val.0 {
                     return Ok(false);
@@ -1111,18 +1094,11 @@ impl<
     }
 
     fn iter(&'a self) -> impl Iterator<Item = (NodeView<'a, &'a Self::Graph>, Self::Value)> + 'a {
-        match &self.state.keys {
-            Some(index) => index
-                .iter()
-                .zip(self.iter_values())
-                .map(|(n, v)| (NodeView::new_internal(&self.state.base_graph, n), v))
-                .into_dyn_boxed(),
-            None => self
-                .iter_values()
-                .enumerate()
-                .map(|(i, v)| (NodeView::new_internal(&self.state.base_graph, VID(i)), v))
-                .into_dyn_boxed(),
-        }
+        self.state
+            .keys_ref()
+            .iter()
+            .zip(self.iter_values())
+            .map(|(n, v)| (NodeView::new_internal(&self.state.base_graph, n), v))
     }
 
     fn nodes(&self) -> Nodes<'graph, Self::Graph> {
@@ -1132,49 +1108,30 @@ impl<
     fn par_iter(
         &'a self,
     ) -> impl ParallelIterator<Item = (NodeView<'a, &'a Self::Graph>, Self::Value)> {
-        match &self.state.keys {
-            Some(index) => Either::Left(
-                index
-                    .par_iter()
-                    .zip(self.par_iter_values())
-                    .map(|(n, v)| (NodeView::new_internal(&self.state.base_graph, n), v)),
-            ),
-            None => Either::Right(
-                self.par_iter_values()
-                    .enumerate()
-                    .map(|(i, v)| (NodeView::new_internal(&self.state.base_graph, VID(i)), v)),
-            ),
-        }
+        let deserializer = Deserializer::from_record_batch(&self.state.values).unwrap();
+        self.state.keys.par_iter().filter_map(move |(i, v)| {
+            Some((
+                NodeView::new_internal(&self.state.base_graph, v),
+                V::deserialize(deserializer.get(i)?).unwrap(),
+            ))
+        })
     }
 
     fn get_by_index(
         &'a self,
         index: usize,
     ) -> Option<(NodeView<'a, &'a Self::Graph>, Self::Value)> {
-        let vid = match &self.state.keys {
-            Some(node_index) => node_index.key(index),
-            None => Some(VID(index)),
-        };
-        if let Some(vid) = vid {
-            Some((
-                NodeView::new_internal(&self.state.base_graph, vid),
-                self.get_by_node(vid).unwrap(), // &self.values[index],
-            ))
-        } else {
-            return None;
-        }
+        let vid = self.state.keys.value(index)?;
+        let deserializer = Deserializer::from_record_batch(&self.state.values).unwrap();
+        let item = V::deserialize(deserializer.get(index)?).unwrap();
+
+        Some((NodeView::new_internal(&self.state.base_graph, vid), item))
     }
 
     fn get_by_node<N: AsNodeRef>(&'a self, node: N) -> Option<Self::Value> {
         let index = self.state.get_index_by_node(&node)?;
         let deserializer = Deserializer::from_record_batch(&self.state.values).unwrap();
-        let item = V::deserialize(
-            deserializer
-                .get(index)
-                .ok_or_else(|| tracing::error!("Could not get item"))
-                .unwrap(),
-        )
-        .unwrap();
+        let item = V::deserialize(deserializer.get(index).unwrap()).unwrap();
         Some(item)
     }
 
@@ -1196,7 +1153,7 @@ impl<
         let state = GenericNodeState::new_from_eval_with_index(
             base_graph,
             values,
-            Some(Index::new(keys)),
+            Index::new(keys),
             Some(self.state.node_cols.clone()),
         );
         TypedNodeState::<'graph, V, Self::Graph, T> {
@@ -1209,29 +1166,19 @@ impl<
 }
 
 impl<'graph, G: GraphViewOps<'graph>> GenericNodeState<'graph, G> {
-    fn take_values<V: NodeStateValue>(index: &Option<Index<VID>>, values: Vec<V>) -> Vec<V> {
-        let Some(index) = index else {
-            return values;
-        };
-
-        let mut values: Vec<Option<V>> = values.into_iter().map(Some).collect();
-
-        index
-            .iter()
-            .map(|vid| {
-                values
-                    .get_mut(vid.0)
-                    .and_then(Option::take)
-                    .expect("index out of bounds")
-            })
-            .collect()
-    }
-
     pub fn new_from_eval_with_index<V: NodeStateValue>(
         graph: G,
         values: Vec<V>,
-        index: Option<Index<VID>>,
-        node_cols: Option<HashMap<String, (NodeStateOutputType, Option<G>)>>,
+        index: Index<VID>,
+        node_cols: Option<
+            HashMap<
+                String,
+                (
+                    NodeStateOutputType,
+                    Option<Arc<dyn BoxableGraphView + 'graph>>,
+                ),
+            >,
+        >,
     ) -> Self {
         Self::new_from_eval_with_index_mapped(graph, values, index, |v| v, node_cols)
     }
@@ -1239,14 +1186,25 @@ impl<'graph, G: GraphViewOps<'graph>> GenericNodeState<'graph, G> {
     pub fn new_from_eval_with_index_mapped<R: Clone, V: NodeStateValue>(
         graph: G,
         values: Vec<R>,
-        index: Option<Index<VID>>,
+        index: Index<VID>,
         map: impl Fn(R) -> V,
-        node_cols: Option<HashMap<String, (NodeStateOutputType, Option<G>)>>,
+        node_cols: Option<
+            HashMap<
+                String,
+                (
+                    NodeStateOutputType,
+                    Option<Arc<dyn BoxableGraphView + 'graph>>,
+                ),
+            >,
+        >,
     ) -> Self {
         let values: Vec<V> = values.into_iter().map(map).collect();
-        let fields = Vec::<FieldRef>::from_type::<V>(TracingOptions::default()).unwrap();
-        let values = Self::take_values(&index, values);
-        let values = Self::convert_recordbatch(to_record_batch(&fields, &values).unwrap()).unwrap();
+        let fields = Vec::<Field>::from_type::<V>(TracingOptions::default()).unwrap();
+        let fields: Vec<_> = fields
+            .into_iter()
+            .map(|field| FieldRef::new(field.with_nullable(true)))
+            .collect();
+        let values = to_record_batch(&fields, &values).unwrap();
         Self::new(graph, values, index, node_cols)
     }
 
@@ -1255,7 +1213,7 @@ impl<'graph, G: GraphViewOps<'graph>> GenericNodeState<'graph, G> {
         Self::new(
             graph.clone(),
             RecordBatch::new_empty(Schema::empty().into()),
-            Some(Index::default()),
+            Index::default(),
             None,
         )
     }
@@ -1268,7 +1226,15 @@ impl<'graph, G: GraphViewOps<'graph>> GenericNodeState<'graph, G> {
     pub fn new_from_eval<V: NodeStateValue>(
         graph: G,
         values: Vec<V>,
-        node_cols: Option<HashMap<String, (NodeStateOutputType, Option<G>)>>,
+        node_cols: Option<
+            HashMap<
+                String,
+                (
+                    NodeStateOutputType,
+                    Option<Arc<dyn BoxableGraphView + 'graph>>,
+                ),
+            >,
+        >,
     ) -> Self {
         Self::new_from_eval_mapped(graph, values, |v| v, node_cols)
     }
@@ -1283,7 +1249,15 @@ impl<'graph, G: GraphViewOps<'graph>> GenericNodeState<'graph, G> {
         graph: G,
         values: Vec<R>,
         map: impl Fn(R) -> V,
-        node_cols: Option<HashMap<String, (NodeStateOutputType, Option<G>)>>,
+        node_cols: Option<
+            HashMap<
+                String,
+                (
+                    NodeStateOutputType,
+                    Option<Arc<dyn BoxableGraphView + 'graph>>,
+                ),
+            >,
+        >,
     ) -> Self {
         let index = Index::for_graph(graph.clone());
         Self::new_from_eval_with_index_mapped(graph.clone(), values, index, map, node_cols)
@@ -1294,7 +1268,15 @@ impl<'graph, G: GraphViewOps<'graph>> GenericNodeState<'graph, G> {
     pub fn new_from_values(
         graph: G,
         values: impl Into<RecordBatch>,
-        node_cols: Option<HashMap<String, (NodeStateOutputType, Option<G>)>>,
+        node_cols: Option<
+            HashMap<
+                String,
+                (
+                    NodeStateOutputType,
+                    Option<Arc<dyn BoxableGraphView + 'graph>>,
+                ),
+            >,
+        >,
     ) -> Self {
         let index = Index::for_graph(&graph);
         Self::new(
@@ -1310,7 +1292,15 @@ impl<'graph, G: GraphViewOps<'graph>> GenericNodeState<'graph, G> {
         graph: G,
         mut values: HashMap<VID, R, S>,
         map: impl Fn(R) -> V,
-        node_cols: Option<HashMap<String, (NodeStateOutputType, Option<G>)>>,
+        node_cols: Option<
+            HashMap<
+                String,
+                (
+                    NodeStateOutputType,
+                    Option<Arc<dyn BoxableGraphView + 'graph>>,
+                ),
+            >,
+        >,
     ) -> Self {
         let fields = Vec::<FieldRef>::from_type::<V>(TracingOptions::default()).unwrap();
         if values.len() == graph.count_nodes() {
@@ -1328,7 +1318,7 @@ impl<'graph, G: GraphViewOps<'graph>> GenericNodeState<'graph, G> {
                 .flat_map(|node| Some((node.node, map(values.remove(&node.node)?))))
                 .unzip();
             let values = to_record_batch(&fields, &values).unwrap();
-            Self::new(graph.clone(), values, Some(Index::new(index)), node_cols)
+            Self::new(graph.clone(), values, Index::new(index), node_cols)
         }
     }
 
@@ -1423,16 +1413,11 @@ impl<'graph, G: GraphViewOps<'graph>> GenericNodeState<'graph, G> {
 
         // Create indices and sort by row comparison and use this to reorder keys
         let mut indices: Vec<u32> = (0..self.values.num_rows() as u32).collect();
-        let new_keys: Option<Index<VID>> = match &self.keys {
-            Some(keys) => Some(
-                indices
-                    .iter()
-                    .filter_map(|&i| keys.index.get_index(i as usize).copied())
-                    .collect(),
-            ),
-            None => Some(indices.iter().map(|&i| VID(i as usize)).collect()),
-        };
         indices.par_sort_by(|&a, &b| rows.row(a as usize).cmp(&rows.row(b as usize)));
+        let new_keys: Index<_> = indices
+            .iter()
+            .filter_map(|&i| self.keys.value(i as usize))
+            .collect();
 
         // Apply sorted indices to all columns
         let indices_array = UInt32Array::from(indices);
@@ -1533,15 +1518,10 @@ impl<'graph, G: GraphViewOps<'graph>> GenericNodeState<'graph, G> {
         // Build the output via interleave.
         let batches = [self.values()];
         let indices: Vec<(usize, usize)> = sorted.iter().map(|r| (0, r.index)).collect();
-        let new_keys: Option<Index<VID>> = match &self.keys {
-            Some(keys) => Some(
-                indices
-                    .iter()
-                    .filter_map(|(_, i)| keys.index.get_index(*i as usize).copied())
-                    .collect(),
-            ),
-            None => Some(indices.iter().map(|(_, i)| VID(*i as usize)).collect()),
-        };
+        let new_keys: Index<_> = indices
+            .iter()
+            .filter_map(|(_, i)| self.keys.value(*i))
+            .collect();
 
         Ok(GenericNodeState::new(
             self.base_graph.clone(),
diff --git a/raphtory/src/db/api/state/group_by.rs b/raphtory/src/db/api/state/group_by.rs
index e99329c4c6..18d72143d6 100644
--- a/raphtory/src/db/api/state/group_by.rs
+++ b/raphtory/src/db/api/state/group_by.rs
@@ -43,7 +43,7 @@ impl<'graph, V: Hash + Eq + Send + Sync + Clone, G: GraphViewOps<'graph>> NodeGr
                     self.graph.clone(),
                     self.graph.clone(),
                     Const(true),
-                    Some(nodes.clone()),
+                    nodes.clone(),
                 ),
             )
         })
@@ -89,7 +89,7 @@ impl<'graph, V: Hash + Eq + Send + Sync + Clone, G: GraphViewOps<'graph>> NodeGr
                     self.graph.clone(),
                     self.graph.clone(),
                     Const(true),
-                    Some(nodes.clone()),
+                    nodes.clone(),
                 ),
             )
         })
diff --git a/raphtory/src/db/api/state/lazy_node_state.rs b/raphtory/src/db/api/state/lazy_node_state.rs
index e43f597d2e..b5f9eb2309 100644
--- a/raphtory/src/db/api/state/lazy_node_state.rs
+++ b/raphtory/src/db/api/state/lazy_node_state.rs
@@ -1,6 +1,6 @@
 use super::node_state_ops::ToOwnedValue;
 use crate::{
-    core::entities::{nodes::node_ref::AsNodeRef, VID},
+    core::entities::nodes::node_ref::AsNodeRef,
     db::{
         api::{
             state::{
@@ -29,7 +29,10 @@ use crate::{
 };
 use chrono::{DateTime, Utc};
 use indexmap::IndexSet;
-use raphtory_api::core::storage::timeindex::{AsTime, EventTime, TimeError};
+use raphtory_api::core::{
+    entities::VID,
+    storage::timeindex::{AsTime, EventTime, TimeError},
+};
 use rayon::prelude::*;
 use serde::{Deserialize, Serialize};
 use std::fmt::{Debug, Formatter};
@@ -230,11 +233,11 @@ impl<
             NodeState::new(
                 self.nodes.graph.clone(),
                 values.into(),
-                Some(Index::new(keys)),
+                Index::Partial(keys.into()),
             )
         } else {
             let values = self.collect_vec();
-            NodeState::new(self.nodes.graph.clone(), values.into(), None)
+            NodeState::new_from_eval(self.nodes.graph.clone(), values.into())
         }
     }
 
@@ -252,14 +255,13 @@ impl<
             Ok(NodeState::new(
                 self.nodes.base_graph.clone(),
                 values?.into(),
-                Some(Index::new(keys)),
+                Index::new(keys),
             ))
         } else {
             let values: Result<Vec<T>, E> = self.collect::<Result<Vec<T>, E>>();
-            Ok(NodeState::new(
+            Ok(NodeState::new_from_eval(
                 self.nodes.base_graph.clone(),
                 values?.into(),
-                None,
             ))
         }
     }
@@ -270,21 +272,21 @@ impl<
         O: NodeOp<Output = Result<T, E>>,
     {
         if self.nodes.is_filtered() {
-            let (keys, values): (IndexSet<_, ahash::RandomState>, Vec<T>) = self
+            let (_, values): (IndexSet<_, ahash::RandomState>, Vec<T>) = self
                 .par_iter()
                 .filter_map(|(node, value)| value.ok().map(|value| (node.node, value)))
                 .unzip();
             NodeState::new(
                 self.nodes.base_graph.clone(),
                 values.into(),
-                Some(Index::new(keys)),
+                Index::for_graph(self.nodes.graph.clone()),
             )
         } else {
             let values: Vec<T> = self
                 .par_iter_values()
                 .filter_map(|value| value.ok())
                 .collect();
-            NodeState::new(self.nodes.base_graph.clone(), values.into(), None)
+            NodeState::new_from_eval(self.nodes.base_graph.clone(), values.into())
         }
     }
 
@@ -301,20 +303,21 @@ impl<
             GenericNodeState::new_from_eval_with_index(
                 self.nodes.base_graph.clone(),
                 values,
-                Some(Index::new(keys)),
+                Index::new(keys),
                 None,
             )
         } else {
             let storage = self.graph().core_graph().lock();
             let values = self
                 .nodes
-                .par_iter_refs()
+                .par_iter_refs(storage.clone())
                 .map(move |vid| self.op.arrow_apply(&storage, vid))
                 .collect();
+            let index = Index::for_graph(self.graph());
             GenericNodeState::new_from_eval_with_index(
                 self.nodes.base_graph.clone(),
                 values,
-                None,
+                index,
                 None,
             )
         }
@@ -631,14 +634,14 @@ impl<
     fn iter_values(&'a self) -> impl Iterator<Item = Self::Value> + 'a {
         let storage = self.graph().core_graph().lock();
         self.nodes
-            .iter_refs()
+            .iter_vids(storage.clone())
             .map(move |vid| self.op.apply(&storage, vid))
     }
 
     fn par_iter_values(&'a self) -> impl ParallelIterator<Item = Self::Value> + 'a {
         let storage = self.graph().core_graph().lock();
         self.nodes
-            .par_iter_refs()
+            .par_iter_refs(storage.clone())
             .map(move |vid| self.op.apply(&storage, vid))
     }
 
@@ -646,7 +649,7 @@ impl<
     fn into_iter_values(self) -> impl Iterator<Item = Self::OwnedValue> + Send + Sync + 'graph {
         let storage = self.graph().core_graph().lock();
         self.nodes
-            .iter_refs()
+            .iter_vids(storage.clone())
             .map(move |vid| self.op.apply(&storage, vid))
     }
 
@@ -654,7 +657,7 @@ impl<
     fn into_par_iter_values(self) -> impl ParallelIterator<Item = Self::OwnedValue> + 'graph {
         let storage = self.graph().core_graph().lock();
         self.nodes
-            .par_iter_refs()
+            .par_iter_refs(storage.clone())
             .map(move |vid| self.op.apply(&storage, vid))
     }
 
@@ -682,24 +685,22 @@ impl<
         &'a self,
         index: usize,
     ) -> Option<(NodeView<'a, &'a Self::Graph>, Self::Value)> {
-        if self.graph().filtered() {
-            self.iter().nth(index)
-        } else {
+        if self.graph().node_list_trusted() {
             let vid = match self.nodes().node_list() {
-                NodeList::All { len } => {
-                    if index < len {
-                        VID(index)
-                    } else {
-                        return None;
-                    }
-                }
-                NodeList::List { elems } => elems.key(index)?,
+                NodeList::All => self
+                    .graph()
+                    .core_graph()
+                    .node_state_index()
+                    .global_index(index)?,
+                NodeList::List { elems } => elems.value(index)?,
             };
             let cg = self.graph().core_graph();
             Some((
                 NodeView::new_internal(self.graph(), vid),
                 self.op.apply(cg, vid),
             ))
+        } else {
+            self.iter().nth(index)
         }
     }
 
@@ -723,7 +724,7 @@ impl<
         Self::BaseGraph: 'graph,
         Self::Graph: 'graph,
     {
-        NodeState::new(graph, values.into(), Some(Index::new(keys)))
+        NodeState::new(graph, values.into(), Index::new(keys))
     }
 }
 
diff --git a/raphtory/src/db/api/state/mod.rs b/raphtory/src/db/api/state/mod.rs
index 8bc04c6ce8..65d60b5eaa 100644
--- a/raphtory/src/db/api/state/mod.rs
+++ b/raphtory/src/db/api/state/mod.rs
@@ -15,7 +15,7 @@ pub use lazy_node_state::{
     AvgIntervalStruct, DateTimeStruct, DateTimesStruct, EventIdStruct, EventIdsStruct,
     IntervalStruct, IntervalsStruct, LazyNodeState, TimeStampStruct, TimeStampsStruct,
 };
-pub use node_state::{Index, NodeState};
+pub use node_state::{Index, IndexIntoIter, NodeState};
 pub use node_state_ops::NodeStateOps;
 pub use node_state_ord_ops::{AsOrderedNodeStateOps, OrderedNodeStateOps};
 pub use ops::NodeOp;
diff --git a/raphtory/src/db/api/state/node_state.rs b/raphtory/src/db/api/state/node_state.rs
index 5bf50d29bd..557a6593a3 100644
--- a/raphtory/src/db/api/state/node_state.rs
+++ b/raphtory/src/db/api/state/node_state.rs
@@ -20,6 +20,7 @@ use crate::{
     prelude::{GraphViewOps, NodeViewOps},
 };
 use indexmap::IndexSet;
+use iter_enum::{DoubleEndedIterator, ExactSizeIterator, FusedIterator, Iterator};
 use raphtory_api::core::storage::timeindex::EventTime;
 use rayon::{iter::Either, prelude::*};
 use std::{
@@ -27,98 +28,209 @@ use std::{
     fmt::{Debug, Formatter},
     hash::{BuildHasher, Hash},
     marker::PhantomData,
+    ops::Range,
     sync::Arc,
 };
+use storage::state::{StateIndex, StateIndexIter};
 
-#[derive(Debug, Default)]
-pub struct Index<K> {
-    pub(crate) index: Arc<IndexSet<K, ahash::RandomState>>,
+#[derive(Debug)]
+pub enum Index<K> {
+    Full(Arc<StateIndex<K>>),
+    Partial(Arc<IndexSet<K, ahash::RandomState>>),
+}
+
+impl<K> From<StateIndex<K>> for Index<K> {
+    fn from(index: StateIndex<K>) -> Self {
+        Self::Full(index.into())
+    }
+}
+
+impl<K> Default for Index<K> {
+    fn default() -> Self {
+        Self::Partial(Arc::new(Default::default()))
+    }
 }
 
 impl<K> Clone for Index<K> {
     fn clone(&self) -> Self {
-        let index = self.index.clone();
-        Self { index }
+        match self {
+            Index::Full(index) => Index::Full(index.clone()),
+            Index::Partial(index) => Index::Partial(index.clone()),
+        }
     }
 }
 
 impl<K: Copy + Eq + Hash + Into<usize> + From<usize> + Send + Sync> FromIterator<K> for Index<K> {
     fn from_iter<T: IntoIterator<Item = K>>(iter: T) -> Self {
-        Self {
-            index: Arc::new(IndexSet::from_iter(iter)),
-        }
+        Self::Partial(Arc::new(IndexSet::from_iter(iter)))
     }
 }
-
 impl Index<VID> {
-    pub fn for_graph<'graph>(graph: impl GraphViewOps<'graph>) -> Option<Self> {
-        if graph.filtered() {
-            if graph.node_list_trusted() {
-                match graph.node_list() {
-                    NodeList::All { .. } => None,
-                    NodeList::List { elems } => Some(elems),
-                }
-            } else {
-                Some(Self::from_iter(graph.nodes().iter().map(|node| node.node)))
+    pub fn for_graph<'graph>(graph: impl GraphViewOps<'graph>) -> Self {
+        if graph.node_list_trusted() {
+            match graph.node_list() {
+                NodeList::All { .. } => Self::Full(graph.core_graph().node_state_index().into()),
+                NodeList::List { elems } => elems,
             }
         } else {
-            None
+            Self::from_iter(graph.nodes().iter().map(|node| node.node))
         }
     }
 }
 
 impl<K: Copy + Eq + Hash + Into<usize> + From<usize> + Send + Sync> Index<K> {
     pub fn new(keys: impl Into<Arc<IndexSet<K, ahash::RandomState>>>) -> Self {
-        Self { index: keys.into() }
+        Self::Partial(keys.into())
     }
 
     #[inline]
     pub fn iter(&self) -> impl Iterator<Item = K> + '_ {
-        self.index.iter().copied()
-    }
-
-    pub fn into_par_iter(self) -> impl IndexedParallelIterator<Item = K> {
-        (0..self.len())
-            .into_par_iter()
-            .map(move |i| *self.index.get_index(i).unwrap())
+        match self {
+            Index::Full(index) => Either::Left(index.iter()),
+            Index::Partial(index) => Either::Right(index.iter().copied()),
+        }
     }
 
-    pub fn into_iter(self) -> impl Iterator<Item = K> {
-        (0..self.len()).map(move |i| *self.index.get_index(i).unwrap())
+    pub fn into_par_iter(self) -> impl ParallelIterator<Item = K> {
+        match self {
+            Index::Full(index) => Either::Left(index.into_par_iter().map(|(_, k)| k)),
+            Index::Partial(index) => Either::Right(
+                (0..index.len())
+                    .into_par_iter()
+                    .map(move |i| *index.get_index(i).unwrap()),
+            ),
+        }
     }
 
     #[inline]
     pub fn index(&self, key: &K) -> Option<usize> {
-        self.index.get_index_of(key)
+        // self.index.get_index_of(key)
+        match self {
+            Index::Full(index) => index.resolve(*key),
+            Index::Partial(index) => index.get_index_of(key),
+        }
     }
 
     #[inline]
-    pub fn key(&self, index: usize) -> Option<K> {
-        self.index.get_index(index).copied()
+    pub fn value(&self, i: usize) -> Option<K> {
+        match self {
+            Index::Full(index) => index.global_index(i),
+            Index::Partial(index) => index.get_index(i).copied(),
+        }
     }
 
     #[inline]
     pub fn len(&self) -> usize {
-        self.index.len()
+        match self {
+            Index::Full(index) => index.len(),
+            Index::Partial(index) => index.len(),
+        }
     }
 
     pub fn is_empty(&self) -> bool {
-        self.index.is_empty()
+        self.len() == 0
     }
 
     #[inline]
     pub fn contains(&self, key: &K) -> bool {
-        self.index.contains(key)
+        match self {
+            Index::Full(index) => index.resolve(*key).is_some(),
+            Index::Partial(index) => index.contains(key),
+        }
     }
 
-    pub fn par_iter(&self) -> impl IndexedParallelIterator<Item = K> + '_ {
-        (0..self.len())
-            .into_par_iter()
-            .map(move |i| *self.index.get_index(i).unwrap())
+    pub fn par_iter(&self) -> impl ParallelIterator<Item = (usize, K)> + '_ {
+        match self {
+            Index::Full(index) => Either::Left(index.par_iter()),
+            Index::Partial(index) => {
+                Either::Right(index.par_iter().enumerate().map(|(i, v)| (i, *v)))
+            }
+        }
     }
 
     pub fn intersection(&self, other: &Self) -> Self {
-        self.index.intersection(&other.index).copied().collect()
+        match (self, other) {
+            (Self::Full(_), Self::Partial(a)) => Self::Partial(a.clone()),
+            (Self::Partial(a), Self::Full(_)) => Self::Partial(a.clone()),
+            (Self::Partial(a), Self::Partial(b)) => a.intersection(b).copied().collect(),
+            _ => self.clone(),
+        }
+    }
+
+    pub fn union(&self, other: &Self) -> Self {
+        match (self, other) {
+            (Self::Full(index), Self::Partial(_)) | (Self::Partial(_), Self::Full(index)) => {
+                Self::Full(index.clone())
+            }
+            (Self::Full(left), Self::Full(right)) => Self::Full(Arc::new(left.union(right))),
+            (Self::Partial(left), Self::Partial(right)) => left.union(right).copied().collect(),
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct PartialIndexIntoIter<K> {
+    range: Range<usize>,
+    index: Arc<IndexSet<K, ahash::RandomState>>,
+}
+
+impl<K: Eq + Hash + Copy> Iterator for PartialIndexIntoIter<K> {
+    type Item = K;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let i = self.range.next()?;
+        self.index.get_index(i).copied()
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.range.size_hint()
+    }
+
+    fn count(self) -> usize
+    where
+        Self: Sized,
+    {
+        self.range.count()
+    }
+
+    fn nth(&mut self, n: usize) -> Option<Self::Item> {
+        let i = self.range.nth(n)?;
+        self.index.get_index(i).copied()
+    }
+}
+
+impl<K: Eq + Hash + Copy> DoubleEndedIterator for PartialIndexIntoIter<K> {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        let i = self.range.next_back()?;
+        self.index.get_index(i).copied()
+    }
+
+    fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
+        let i = self.range.nth_back(n)?;
+        self.index.get_index(i).copied()
+    }
+}
+
+impl<K: Eq + Hash + Copy> ExactSizeIterator for PartialIndexIntoIter<K> {}
+
+#[derive(Clone, Iterator, DoubleEndedIterator, ExactSizeIterator, FusedIterator)]
+pub enum IndexIntoIter<K> {
+    Full(StateIndexIter<Arc<StateIndex<K>>, K>),
+    Partial(PartialIndexIntoIter<K>),
+}
+
+impl<K: Copy + Eq + Hash + Into<usize> + From<usize> + Send + Sync> IntoIterator for Index<K> {
+    type Item = K;
+    type IntoIter = IndexIntoIter<K>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        match self {
+            Index::Full(index) => IndexIntoIter::Full(index.arc_into_iter()),
+            Index::Partial(index) => IndexIntoIter::Partial(PartialIndexIntoIter {
+                range: 0..index.len(),
+                index,
+            }),
+        }
     }
 }
 
@@ -126,7 +238,7 @@ impl<K: Copy + Eq + Hash + Into<usize> + From<usize> + Send + Sync> Index<K> {
 pub struct NodeState<'graph, V, G> {
     base_graph: G,
     values: Arc<[V]>,
-    keys: Option<Index<VID>>,
+    keys: Index<VID>,
     _marker: PhantomData<&'graph ()>,
 }
 
@@ -198,43 +310,64 @@ impl<'graph, V, G: GraphViewOps<'graph>> NodeState<'graph, V, G> {
     ///
     /// # Arguments
     /// - `graph`: the graph view
-    /// - `values`: the unfiltered values (i.e., `values.len() == graph.unfiltered_num_nodes()`). This method handles the filtering.
-    pub fn new_from_eval(graph: G, values: Vec<V>) -> Self
-    where
-        V: Clone,
-    {
+    /// - `values`: the values indexed by flat position (i.e., `values.len() == index.len()`).
+    pub fn new_from_eval(graph: G, values: Vec<V>) -> Self {
         let index = Index::for_graph(graph.clone());
-        let values = match &index {
-            None => values,
-            Some(index) => index
-                .iter()
-                .map(|vid| values[vid.index()].clone())
-                .collect(),
-        };
+        // Values are already in flat index order from TaskRunner
         Self::new(graph, values.into(), index)
     }
 
+    /// Construct a node state from an eval result
+    ///
+    /// # Arguments
+    /// - `graph`: the graph view
+    /// - `values`: the values indexed by flat position (i.e., `values.len() == index.len()`).
+    /// - `index`: the index mapping VID to flat position in values
+    pub fn new_from_eval_with_index(graph: G, values: Vec<V>, index: Index<VID>) -> Self {
+        // Values are already in flat index order from TaskRunner
+        Self::new(graph, values.into(), index)
+    }
+
+    /// Construct a node state from an eval result, mapping values
+    ///
+    /// # Arguments
+    /// - `graph`: the graph view
+    /// - `values`: the values indexed by flat position (i.e., `values.len() == index.len()`).
+    /// - `map`: Closure mapping input to output values
+    pub fn new_from_eval_mapped_with_index<R: Clone>(
+        graph: G,
+        values: Vec<R>,
+        index: Index<VID>,
+        map: impl Fn(R) -> V,
+    ) -> Self
+    where
+        V: std::fmt::Debug,
+    {
+        // Values are already in flat index order from TaskRunner, just map them
+        let values = values.into_iter().map(map).collect();
+        Self::new(graph, values, index)
+    }
+
     /// Construct a node state from an eval result, mapping values
     ///
     /// # Arguments
     /// - `graph`: the graph view
-    /// - `values`: the unfiltered values (i.e., `values.len() == graph.unfiltered_num_nodes()`). This method handles the filtering.
+    /// - `values`: the values indexed by flat position (i.e., `values.len() == index.len()`).
     /// - `map`: Closure mapping input to output values
-    pub fn new_from_eval_mapped<R: Clone>(graph: G, values: Vec<R>, map: impl Fn(R) -> V) -> Self {
+    pub fn new_from_eval_mapped<R: Clone>(graph: G, values: Vec<R>, map: impl Fn(R) -> V) -> Self
+    where
+        V: std::fmt::Debug,
+    {
         let index = Index::for_graph(graph.clone());
-        let values = match &index {
-            None => values.into_iter().map(map).collect(),
-            Some(index) => index
-                .iter()
-                .map(|vid| map(values[vid.index()].clone()))
-                .collect(),
-        };
+        // Values are already in flat index order from TaskRunner, just map them
+        let values = values.into_iter().map(map).collect();
         Self::new(graph, values, index)
     }
 
     /// create a new empty NodeState
     pub fn new_empty(graph: G) -> Self {
-        Self::new(graph, [].into(), Some(Index::default()))
+        let index = Index::for_graph(&graph);
+        Self::new(graph, [].into(), index)
     }
 
     /// create a new NodeState from a list of values for the node (takes care of creating an index for
@@ -263,13 +396,17 @@ impl<'graph, V, G: GraphViewOps<'graph>> NodeState<'graph, V, G> {
                 .iter()
                 .flat_map(|node| Some((node.node, map(values.remove(&node.node)?))))
                 .unzip();
-            Self::new(graph, values.into(), Some(Index::new(index)))
+            Self::new(graph, values.into(), Index::Partial(index.into()))
         }
     }
+
+    pub fn keys(&self) -> &Index<VID> {
+        &self.keys
+    }
 }
 
 impl<'graph, V, G: GraphViewOps<'graph>> NodeState<'graph, V, G> {
-    pub fn new(base_graph: G, values: Arc<[V]>, keys: Option<Index<VID>>) -> Self {
+    pub fn new(base_graph: G, values: Arc<[V]>, keys: Index<VID>) -> Self {
         Self {
             base_graph,
             values,
@@ -278,15 +415,11 @@ impl<'graph, V, G: GraphViewOps<'graph>> NodeState<'graph, V, G> {
         }
     }
 
-    pub fn into_inner(self) -> (Arc<[V]>, Option<Index<VID>>) {
-        (self.values, self.keys)
-    }
-
     pub fn values(&self) -> &Arc<[V]> {
         &self.values
     }
 
-    pub fn ids(&self) -> &Option<Index<VID>> {
+    pub fn ids(&self) -> &Index<VID> {
         &self.keys
     }
 }
@@ -354,19 +487,10 @@ impl<'a, 'graph: 'a, V: Clone + Send + Sync + 'graph, G: GraphViewOps<'graph>>
     where
         'graph: 'a,
     {
-        match &self.keys {
-            Some(index) => index
-                .iter()
-                .zip(self.values.iter())
-                .map(|(n, v)| (NodeView::new_internal(&self.base_graph, n), v))
-                .into_dyn_boxed(),
-            None => self
-                .values
-                .iter()
-                .enumerate()
-                .map(|(i, v)| (NodeView::new_internal(&self.base_graph, VID(i)), v))
-                .into_dyn_boxed(),
-        }
+        self.keys
+            .iter()
+            .zip(self.values.iter())
+            .map(move |(n, v)| (NodeView::new_internal(&self.base_graph, n), v))
     }
 
     fn nodes<'g>(&self) -> Nodes<'graph, Self::BaseGraph, Self::Graph, Self::Select> {
@@ -389,46 +513,28 @@ impl<'a, 'graph: 'a, V: Clone + Send + Sync + 'graph, G: GraphViewOps<'graph>>
     where
         'graph: 'a,
     {
-        match &self.keys {
-            Some(index) => Either::Left(
-                index
-                    .par_iter()
-                    .zip(self.values.par_iter())
-                    .map(|(n, v)| (NodeView::new_internal(&self.base_graph, n), v)),
-            ),
-            None => Either::Right(
-                self.values
-                    .par_iter()
-                    .enumerate()
-                    .map(|(i, v)| (NodeView::new_internal(&self.base_graph, VID(i)), v)),
-            ),
-        }
+        self.keys.par_iter().map(move |(val_id, n)| {
+            (
+                NodeView::new_internal(&self.base_graph, n),
+                &self.values[val_id],
+            )
+        })
     }
 
     fn get_by_index(
         &'a self,
         index: usize,
     ) -> Option<(NodeView<'a, &'a Self::Graph>, Self::Value)> {
-        match &self.keys {
-            Some(node_index) => node_index.key(index).map(|n| {
-                (
-                    NodeView::new_internal(&self.base_graph, n),
-                    &self.values[index],
-                )
-            }),
-            None => self
-                .values
-                .get(index)
-                .map(|v| (NodeView::new_internal(&self.base_graph, VID(index)), v)),
-        }
+        let vid = self.keys.value(index)?;
+        Some((
+            NodeView::new_internal(&self.base_graph, vid),
+            &self.values[index],
+        ))
     }
 
     fn get_by_node<N: AsNodeRef>(&'a self, node: N) -> Option<Self::Value> {
         let id = self.base_graph.internalise_node(node.as_node_ref())?;
-        match &self.keys {
-            Some(index) => index.index(&id).map(|i| &self.values[i]),
-            None => Some(&self.values[id.0]),
-        }
+        self.keys.index(&id).map(|i| &self.values[i])
     }
 
     fn len(&self) -> usize {
@@ -446,7 +552,7 @@ impl<'a, 'graph: 'a, V: Clone + Send + Sync + 'graph, G: GraphViewOps<'graph>>
         Self::BaseGraph: 'graph,
         Self::Graph: 'graph,
     {
-        NodeState::new(base_graph, values.into(), Some(Index::new(keys)))
+        NodeState::new(base_graph, values.into(), Index::new(keys))
     }
 }
 
@@ -520,20 +626,9 @@ mod test {
     #[test]
     fn float_state() {
         let g = Graph::new();
-        g.add_node(0, 0, NO_PROPS, None).unwrap();
-        let float_state = NodeState {
-            base_graph: g.clone(),
-            values: [0.0f64].into(),
-            keys: None,
-            _marker: Default::default(),
-        };
-
-        let int_state = NodeState {
-            base_graph: g.clone(),
-            values: [1i64].into(),
-            keys: None,
-            _marker: Default::default(),
-        };
+        g.add_node(0, 0, NO_PROPS, None, None).unwrap();
+        let float_state = NodeState::new_from_values(g.clone(), [0.0f64]);
+        let int_state = NodeState::new_from_values(g.clone(), [1i64]);
         let min_float = float_state.min_item().unwrap().1;
         let min_int = int_state.min_item().unwrap().1;
         assert_eq!(min_float, &0.0);
diff --git a/raphtory/src/db/api/state/node_state_ord_ops.rs b/raphtory/src/db/api/state/node_state_ord_ops.rs
index 8ae6c1dd5e..6421d2bd13 100644
--- a/raphtory/src/db/api/state/node_state_ord_ops.rs
+++ b/raphtory/src/db/api/state/node_state_ord_ops.rs
@@ -407,15 +407,16 @@ where
 mod test {
     use crate::db::api::state::node_state_ord_ops::{par_top_k, top_k};
 
-    use rand; // 0.8.5
-
-    use rand::distributions::{Distribution, Uniform};
+    use rand::{
+        distr::{Distribution, Uniform},
+        Rng,
+    };
     use tokio::time::Instant;
 
     fn gen_x_ints(
         count: u32,
         distribution: impl Distribution<u32>,
-        rng: &mut (impl rand::Rng + ?Sized),
+        rng: &mut (impl Rng + ?Sized),
     ) -> Vec<u32> {
         let mut results = Vec::with_capacity(count as usize);
         let iter = distribution.sample_iter(rng);
@@ -429,8 +430,8 @@ mod test {
     fn test_top_k() {
         let values = gen_x_ints(
             100_000_000,
-            Uniform::new(0, 10000000),
-            &mut rand::thread_rng(),
+            Uniform::new(0, 10000000).unwrap(),
+            &mut rand::rng(),
         ); // [4i32, 2, 3, 100, 4, 2];
         let timer = Instant::now();
         let res1 = top_k(values.clone(), |a, b| a.cmp(b), 100);
diff --git a/raphtory/src/db/api/state/ops/filter.rs b/raphtory/src/db/api/state/ops/filter.rs
index 9184f63f10..3bd711b295 100644
--- a/raphtory/src/db/api/state/ops/filter.rs
+++ b/raphtory/src/db/api/state/ops/filter.rs
@@ -1,18 +1,29 @@
 use crate::{
     db::{
         api::{
-            state::ops::{Const, IntoDynNodeOp, NodeOp, TypeId},
-            view::internal::GraphView,
+            state::{
+                ops::{Const, IntoDynNodeOp, NodeOp, TypeId},
+                Index,
+            },
+            view::internal::{GraphView, NodeList},
         },
         graph::{
             create_node_type_filter,
-            views::filter::model::{filter::Filter, node_filter::NodeFilter},
+            views::filter::model::{
+                filter::{Filter, FilterValue},
+                node_filter::NodeFilter,
+                FilterOperator,
+            },
         },
     },
     prelude::{GraphViewOps, PropertyFilter},
 };
-use raphtory_api::core::{entities::VID, storage::arc_str::OptionAsStr};
-use raphtory_storage::graph::{graph::GraphStorage, nodes::node_storage_ops::NodeStorageOps};
+use raphtory_api::core::entities::VID;
+use raphtory_core::entities::nodes::node_ref::AsNodeRef;
+use raphtory_storage::{
+    core_ops::CoreGraphOps,
+    graph::{graph::GraphStorage, nodes::node_storage_ops::NodeStorageOps},
+};
 use std::sync::Arc;
 
 #[derive(Clone, Debug)]
@@ -83,6 +94,48 @@ impl NodeOp for NodeIdFilterOp {
         let node = storage.core_node(node);
         self.filter.id_matches(node.id())
     }
+
+    fn domain(&self, storage: &GraphStorage) -> NodeList {
+        let op = &self.filter.operator;
+        match op {
+            FilterOperator::Eq => match &self.filter.field_value {
+                FilterValue::ID(id) => {
+                    let vid = storage.internalise_node(id.as_node_ref());
+                    NodeList::List {
+                        elems: vid.into_iter().collect(),
+                    }
+                }
+                _ => unreachable!(),
+            },
+            FilterOperator::IsIn => match &self.filter.field_value {
+                FilterValue::IDSet(ids) => NodeList::List {
+                    elems: ids
+                        .iter()
+                        .filter_map(|id| storage.internalise_node(id.as_node_ref()))
+                        .collect(),
+                },
+                _ => unreachable!(),
+            },
+            FilterOperator::IsNone => NodeList::empty(),
+            _ => NodeList::All,
+        }
+    }
+
+    fn const_value(&self) -> Option<Self::Output> {
+        match &self.filter.operator {
+            FilterOperator::IsSome => Some(true),
+            _ => None,
+        }
+    }
+    fn const_value_in_domain(&self) -> Option<Self::Output> {
+        match &self.filter.operator {
+            FilterOperator::Eq
+            | FilterOperator::IsIn
+            | FilterOperator::IsNone
+            | FilterOperator::IsSome => Some(true),
+            _ => None,
+        }
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -99,9 +152,53 @@ impl NodeNameFilterOp {
 impl NodeOp for NodeNameFilterOp {
     type Output = bool;
 
+    fn domain(&self, storage: &GraphStorage) -> NodeList {
+        let op = &self.filter.operator;
+        match op {
+            FilterOperator::Eq => match &self.filter.field_value {
+                FilterValue::Single(name) => {
+                    let vid = storage.internalise_node(name.as_node_ref());
+                    NodeList::List {
+                        elems: vid.into_iter().collect(),
+                    }
+                }
+                _ => unreachable!(),
+            },
+            FilterOperator::IsIn => match &self.filter.field_value {
+                FilterValue::Set(names) => NodeList::List {
+                    elems: names
+                        .iter()
+                        .filter_map(|name| storage.internalise_node(name.as_node_ref()))
+                        .collect(),
+                },
+                _ => unreachable!(),
+            },
+            FilterOperator::IsNone => NodeList::List {
+                elems: Index::default(),
+            },
+            _ => NodeList::All,
+        }
+    }
+
     fn apply(&self, storage: &GraphStorage, node: VID) -> Self::Output {
         let node_ref = storage.core_node(node);
-        self.filter.matches(node_ref.name().as_str())
+        self.filter.matches(Some(&node_ref.name()))
+    }
+
+    fn const_value(&self) -> Option<Self::Output> {
+        match &self.filter.operator {
+            FilterOperator::IsSome => Some(true),
+            _ => None,
+        }
+    }
+    fn const_value_in_domain(&self) -> Option<Self::Output> {
+        match &self.filter.operator {
+            FilterOperator::Eq
+            | FilterOperator::IsIn
+            | FilterOperator::IsNone
+            | FilterOperator::IsSome => Some(true),
+            _ => None,
+        }
     }
 }
 
@@ -148,6 +245,33 @@ where
     fn apply(&self, storage: &GraphStorage, node: VID) -> Self::Output {
         self.left.apply(storage, node) || self.right.apply(storage, node)
     }
+
+    fn domain(&self, storage: &GraphStorage) -> NodeList {
+        if matches!(self.const_value_in_domain(), Some(false)) {
+            NodeList::empty()
+        } else {
+            self.left.domain(storage).union(&self.right.domain(storage))
+        }
+    }
+
+    fn const_value_in_domain(&self) -> Option<Self::Output> {
+        match (self.left.const_value(), self.right.const_value()) {
+            (Some(true), _) | (_, Some(true)) => Some(true),
+            (Some(left), Some(right)) => Some(left || right),
+            _ => None,
+        }
+    }
+
+    fn const_value(&self) -> Option<Self::Output> {
+        match (
+            self.left.const_value_in_domain(),
+            self.right.const_value_in_domain(),
+        ) {
+            (Some(true), _) | (_, Some(true)) => Some(true),
+            (Some(left), Some(right)) => Some(left || right),
+            _ => None,
+        }
+    }
 }
 
 impl<L, R> IntoDynNodeOp for OrOp<L, R> where Self: NodeOp + 'static {}
@@ -168,6 +292,35 @@ where
     fn apply(&self, storage: &GraphStorage, node: VID) -> Self::Output {
         self.left.apply(storage, node) && self.right.apply(storage, node)
     }
+
+    fn domain(&self, storage: &GraphStorage) -> NodeList {
+        if matches!(self.const_value_in_domain(), Some(false)) {
+            NodeList::empty()
+        } else {
+            self.left
+                .domain(storage)
+                .intersection(&self.right.domain(storage))
+        }
+    }
+
+    fn const_value(&self) -> Option<Self::Output> {
+        match (self.left.const_value(), self.right.const_value()) {
+            (Some(false), _) | (_, Some(false)) => Some(false),
+            (Some(left), Some(right)) => Some(left && right),
+            _ => None,
+        }
+    }
+
+    fn const_value_in_domain(&self) -> Option<Self::Output> {
+        match (
+            self.left.const_value_in_domain(),
+            self.right.const_value_in_domain(),
+        ) {
+            (Some(false), _) | (_, Some(false)) => Some(false),
+            (Some(left), Some(right)) => Some(left && right),
+            _ => None,
+        }
+    }
 }
 
 impl<L, R> IntoDynNodeOp for AndOp<L, R> where Self: NodeOp + 'static {}
diff --git a/raphtory/src/db/api/state/ops/mod.rs b/raphtory/src/db/api/state/ops/mod.rs
index ee21b55a3c..83afa1851e 100644
--- a/raphtory/src/db/api/state/ops/mod.rs
+++ b/raphtory/src/db/api/state/ops/mod.rs
@@ -3,7 +3,10 @@ pub mod history;
 pub mod node;
 pub mod properties;
 
-use crate::db::api::state::ops::filter::{AndOp, NotOp, OrOp};
+use crate::db::api::{
+    state::ops::filter::{AndOp, NotOp, OrOp},
+    view::internal::NodeList,
+};
 pub use history::*;
 pub use node::*;
 pub use properties::*;
@@ -15,10 +18,21 @@ use std::{fmt::Debug, marker::PhantomData, ops::Deref, sync::Arc};
 pub trait NodeOp: Send + Sync {
     type Output: Clone + Send + Sync;
 
+    /// The domain of validity for this node op
+    fn domain(&self, _storage: &GraphStorage) -> NodeList {
+        NodeList::All
+    }
+
+    /// Returns `Some(value)` if the node op has a constant global value
     fn const_value(&self) -> Option<Self::Output> {
         None
     }
 
+    /// Returns `Some(value)` if the node op has a constant value over the domain
+    fn const_value_in_domain(&self) -> Option<Self::Output> {
+        self.const_value()
+    }
+
     fn apply(&self, storage: &GraphStorage, node: VID) -> Self::Output;
 
     fn map<V: Clone + Send + Sync>(self, map: fn(Self::Output) -> V) -> Map<Self, V>
@@ -59,6 +73,8 @@ pub type DynNodeOp<O> = Arc<dyn NodeOp<Output = O>>;
 pub trait NodeFilterOp: NodeOp<Output = bool> + Clone {
     fn is_filtered(&self) -> bool;
 
+    fn is_domain_filtered(&self) -> bool;
+
     fn and<T>(self, other: T) -> AndOp<Self, T>;
 
     fn or<T>(self, other: T) -> OrOp<Self, T>;
@@ -72,6 +88,10 @@ impl<Op: NodeOp<Output = bool> + Clone> NodeFilterOp for Op {
         self.const_value().is_none_or(|v| !v)
     }
 
+    fn is_domain_filtered(&self) -> bool {
+        self.const_value_in_domain().is_none_or(|v| !v)
+    }
+
     fn and<T>(self, other: T) -> AndOp<Self, T> {
         AndOp {
             left: self,
@@ -147,6 +167,18 @@ impl<'a, V: Clone + Send + Sync> NodeOp for Arc<dyn NodeOp<Output = V> + 'a> {
     fn apply(&self, storage: &GraphStorage, node: VID) -> V {
         self.deref().apply(storage, node)
     }
+
+    fn const_value(&self) -> Option<Self::Output> {
+        self.deref().const_value()
+    }
+
+    fn const_value_in_domain(&self) -> Option<Self::Output> {
+        self.deref().const_value_in_domain()
+    }
+
+    fn domain(&self, storage: &GraphStorage) -> NodeList {
+        self.deref().domain(storage)
+    }
 }
 
 #[derive(Clone, Copy, Debug)]
diff --git a/raphtory/src/db/api/storage/graph/storage_ops/disk_storage.rs b/raphtory/src/db/api/storage/graph/storage_ops/disk_storage.rs
deleted file mode 100644
index 28c6e0d147..0000000000
--- a/raphtory/src/db/api/storage/graph/storage_ops/disk_storage.rs
+++ /dev/null
@@ -1,205 +0,0 @@
-use crate::{
-    db::{
-        api::view::internal::GraphTimeSemanticsOps, graph::views::deletion_graph::PersistentGraph,
-    },
-    errors::GraphError,
-    prelude::{Graph, GraphViewOps, NodeStateOps, NodeViewOps},
-};
-use arrow::array::ArrayRef;
-use itertools::Itertools;
-use pometry_storage::interop::GraphLike;
-use raphtory_api::{
-    core::{
-        entities::{properties::tprop::TPropOps, LayerIds, EID, GID, VID},
-        storage::timeindex::{EventTime, TimeIndexOps},
-        Direction,
-    },
-    iter::IntoDynBoxed,
-};
-use raphtory_core::utils::iter::GenLockedIter;
-use raphtory_storage::{
-    core_ops::CoreGraphOps,
-    disk::{graph_impl::prop_conversion::arrow_array_from_props, DiskGraphStorage},
-    graph::{
-        edges::edge_storage_ops::EdgeStorageOps, graph::GraphStorage,
-        nodes::node_storage_ops::NodeStorageOps,
-    },
-};
-use std::{path::Path, sync::Arc};
-
-impl From<DiskGraphStorage> for Graph {
-    fn from(value: DiskGraphStorage) -> Self {
-        Graph::from_internal_graph(GraphStorage::Disk(Arc::new(value)))
-    }
-}
-
-impl From<DiskGraphStorage> for PersistentGraph {
-    fn from(value: DiskGraphStorage) -> Self {
-        PersistentGraph::from_internal_graph(GraphStorage::Disk(Arc::new(value)))
-    }
-}
-
-pub trait IntoGraph {
-    fn into_graph(self) -> Graph;
-
-    fn into_persistent_graph(self) -> PersistentGraph;
-}
-
-impl IntoGraph for DiskGraphStorage {
-    fn into_graph(self) -> Graph {
-        self.into()
-    }
-
-    fn into_persistent_graph(self) -> PersistentGraph {
-        self.into()
-    }
-}
-
-impl Graph {
-    pub fn persist_as_disk_graph(&self, graph_dir: impl AsRef<Path>) -> Result<Graph, GraphError> {
-        Ok(Graph::from(DiskGraphStorage::from_graph(self, graph_dir)?))
-    }
-}
-
-impl PersistentGraph {
-    pub fn persist_as_disk_graph(
-        &self,
-        graph_dir: impl AsRef<Path>,
-    ) -> Result<PersistentGraph, GraphError> {
-        Ok(PersistentGraph::from(DiskGraphStorage::from_graph(
-            &self.event_graph(),
-            graph_dir,
-        )?))
-    }
-}
-
-impl GraphLike<EventTime> for Graph {
-    fn external_ids(&self) -> Vec<GID> {
-        self.nodes().id().collect()
-    }
-
-    fn node_names(&self) -> impl Iterator<Item = String> {
-        self.nodes().name().into_iter_values()
-    }
-
-    fn node_type_ids(&self) -> Option<impl Iterator<Item = usize>> {
-        if self.core_graph().node_meta().node_type_meta().len() <= 1 {
-            None
-        } else {
-            let core_nodes = self.core_nodes();
-            Some((0..core_nodes.len()).map(move |i| core_nodes.node_entry(VID(i)).node_type_id()))
-        }
-    }
-
-    fn node_types(&self) -> Option<impl Iterator<Item = String>> {
-        let meta = self.core_graph().node_meta().node_type_meta();
-        if meta.len() <= 1 {
-            None
-        } else {
-            Some(meta.get_keys().into_iter().map(|s| s.to_string()))
-        }
-    }
-
-    fn layer_names(&self) -> Vec<String> {
-        self.edge_meta()
-            .layer_meta()
-            .get_keys()
-            .into_iter()
-            .map_into()
-            .collect()
-    }
-
-    fn num_nodes(&self) -> usize {
-        self.unfiltered_num_nodes()
-    }
-
-    fn num_edges(&self) -> usize {
-        self.count_edges()
-    }
-
-    fn out_degree(&self, vid: VID, layer: usize) -> usize {
-        self.core_node(vid.0.into())
-            .degree(&LayerIds::One(layer), Direction::OUT)
-    }
-
-    fn in_degree(&self, vid: VID, layer: usize) -> usize {
-        self.core_node(vid.0.into())
-            .degree(&LayerIds::One(layer), Direction::IN)
-    }
-
-    fn in_edges<B>(&self, vid: VID, layer: usize, map: impl Fn(VID, EID) -> B) -> Vec<B> {
-        let node = self.core_node(vid.0.into());
-        node.edges_iter(&LayerIds::One(layer), Direction::IN)
-            .map(|edge| map(edge.src(), edge.pid()))
-            .collect()
-    }
-    fn out_edges(&self, vid: VID, layer: usize) -> Vec<(VID, VID, EID)> {
-        let node = self.core_node(vid.0.into());
-        let edges = node
-            .edges_iter(&LayerIds::One(layer), Direction::OUT)
-            .map(|edge| {
-                let src = edge.src();
-                let dst = edge.dst();
-                let eid = edge.pid();
-                (src, dst, eid)
-            })
-            .collect();
-        edges
-    }
-
-    fn edge_additions(&self, eid: EID, layer: usize) -> impl Iterator<Item = EventTime> + '_ {
-        let edge = self.core_edge(eid);
-        GenLockedIter::from(edge, |edge| edge.additions(layer).iter().into_dyn_boxed())
-    }
-
-    fn edge_prop_keys(&self) -> Vec<String> {
-        let props = self.edge_meta().temporal_prop_mapper().get_keys();
-        props.into_iter().map(|s| s.to_string()).collect()
-    }
-
-    fn find_name(&self, vid: VID) -> Option<String> {
-        self.core_node(vid.0.into()).name().map(|s| s.to_string())
-    }
-
-    fn prop_as_arrow<S: AsRef<str>>(
-        &self,
-        disk_edges: &[u64],
-        edge_id_map: &[usize],
-        edge_ts: &[EventTime],
-        edge_t_offsets: &[usize],
-        layer: usize,
-        prop_id: usize,
-        _key: S,
-    ) -> Option<ArrayRef> {
-        let prop_type = self
-            .edge_meta()
-            .temporal_prop_mapper()
-            .get_dtype(prop_id)
-            .unwrap();
-        arrow_array_from_props(
-            disk_edges.iter().flat_map(|&disk_eid| {
-                let disk_eid = disk_eid as usize;
-                let eid = edge_id_map[disk_eid];
-                let ts = &edge_ts[edge_t_offsets[disk_eid]..edge_t_offsets[disk_eid + 1]];
-                let edge = self.core_edge(EID(eid));
-                ts.iter()
-                    .map(move |t| edge.temporal_prop_layer(layer, prop_id).at(t))
-            }),
-            prop_type,
-        )
-    }
-
-    fn earliest_time(&self) -> i64 {
-        self.earliest_time_global().unwrap_or(i64::MAX)
-    }
-
-    fn latest_time(&self) -> i64 {
-        self.latest_time_global().unwrap_or(i64::MIN)
-    }
-
-    fn out_neighbours(&self, vid: VID) -> impl Iterator<Item = (VID, EID)> + '_ {
-        self.core_node(vid)
-            .into_edges_iter(&LayerIds::All, Direction::OUT)
-            .map(|e_ref| (e_ref.dst(), e_ref.pid()))
-    }
-}
diff --git a/raphtory/src/db/api/storage/graph/storage_ops/edge_filter.rs b/raphtory/src/db/api/storage/graph/storage_ops/edge_filter.rs
index b78ad0d33a..d7e238c33a 100644
--- a/raphtory/src/db/api/storage/graph/storage_ops/edge_filter.rs
+++ b/raphtory/src/db/api/storage/graph/storage_ops/edge_filter.rs
@@ -5,8 +5,11 @@ use crate::{
         InternalEdgeFilterOps, InternalEdgeLayerFilterOps, InternalExplodedEdgeFilterOps,
     },
 };
-use raphtory_api::core::{entities::ELID, storage::timeindex::EventTime};
-use raphtory_storage::graph::edges::edge_ref::EdgeStorageRef;
+use raphtory_api::core::{
+    entities::{LayerId, ELID},
+    storage::timeindex::EventTime,
+};
+use storage::EdgeEntryRef;
 
 impl InternalEdgeFilterOps for GraphStorage {
     #[inline]
@@ -20,7 +23,7 @@ impl InternalEdgeFilterOps for GraphStorage {
     }
 
     #[inline]
-    fn internal_filter_edge(&self, _edge: EdgeStorageRef, _layer_ids: &LayerIds) -> bool {
+    fn internal_filter_edge(&self, _edge: EdgeEntryRef, _layer_ids: &LayerIds) -> bool {
         true
     }
 
@@ -66,7 +69,7 @@ impl InternalEdgeLayerFilterOps for GraphStorage {
     }
 
     #[inline]
-    fn internal_filter_edge_layer(&self, _edge: EdgeStorageRef, _layer: usize) -> bool {
+    fn internal_filter_edge_layer(&self, _edge: EdgeEntryRef, _layer: LayerId) -> bool {
         true
     }
 
diff --git a/raphtory/src/db/api/storage/graph/storage_ops/list_ops.rs b/raphtory/src/db/api/storage/graph/storage_ops/list_ops.rs
index 0a2ce7e99f..3602043d46 100644
--- a/raphtory/src/db/api/storage/graph/storage_ops/list_ops.rs
+++ b/raphtory/src/db/api/storage/graph/storage_ops/list_ops.rs
@@ -4,15 +4,11 @@ use crate::db::api::view::internal::{EdgeList, ListOps, NodeList};
 impl ListOps for GraphStorage {
     #[inline]
     fn node_list(&self) -> NodeList {
-        NodeList::All {
-            len: self.unfiltered_num_nodes(),
-        }
+        NodeList::All
     }
 
     #[inline]
     fn edge_list(&self) -> EdgeList {
-        EdgeList::All {
-            len: self.unfiltered_num_edges(),
-        }
+        EdgeList::All
     }
 }
diff --git a/raphtory/src/db/api/storage/graph/storage_ops/metadata.rs b/raphtory/src/db/api/storage/graph/storage_ops/metadata.rs
index 1d89b108a1..64ed590893 100644
--- a/raphtory/src/db/api/storage/graph/storage_ops/metadata.rs
+++ b/raphtory/src/db/api/storage/graph/storage_ops/metadata.rs
@@ -1,30 +1,43 @@
-use raphtory_api::core::storage::arc_str::ArcStr;
-
 use crate::{
     db::api::{properties::internal::InternalMetadataOps, view::BoxedLIter},
     prelude::Prop,
 };
+use raphtory_api::{core::storage::arc_str::ArcStr, iter::IntoDynBoxed};
+use storage::api::graph_props::{GraphPropEntryOps, GraphPropRefOps};
 
 use super::GraphStorage;
 
 impl InternalMetadataOps for GraphStorage {
     fn get_metadata_id(&self, name: &str) -> Option<usize> {
-        self.graph_meta().get_metadata_id(name)
+        self.graph_props_meta().metadata_mapper().get_id(name)
     }
 
     fn get_metadata_name(&self, id: usize) -> ArcStr {
-        self.graph_meta().get_metadata_name(id)
+        self.graph_props_meta()
+            .metadata_mapper()
+            .get_name(id)
+            .clone()
     }
 
     fn metadata_ids(&self) -> BoxedLIter<'_, usize> {
-        Box::new(self.graph_meta().metadata_ids())
+        self.graph_props_meta()
+            .metadata_mapper()
+            .ids()
+            .into_dyn_boxed()
     }
 
     fn get_metadata(&self, id: usize) -> Option<Prop> {
-        self.graph_meta().get_metadata(id)
+        let graph_entry = self.graph_entry();
+
+        // Return the metadata value for the given property id.
+        graph_entry.as_ref().get_metadata(id)
     }
 
     fn metadata_keys(&self) -> BoxedLIter<'_, ArcStr> {
-        Box::new(self.graph_meta().metadata_names().into_iter())
+        self.graph_props_meta()
+            .metadata_mapper()
+            .keys()
+            .into_iter()
+            .into_dyn_boxed()
     }
 }
diff --git a/raphtory/src/db/api/storage/graph/storage_ops/mod.rs b/raphtory/src/db/api/storage/graph/storage_ops/mod.rs
index f9aa55f052..0410b6edc1 100644
--- a/raphtory/src/db/api/storage/graph/storage_ops/mod.rs
+++ b/raphtory/src/db/api/storage/graph/storage_ops/mod.rs
@@ -1,8 +1,7 @@
 use crate::db::api::{storage::storage::Storage, view::internal::InternalStorageOps};
 use raphtory_storage::graph::graph::GraphStorage;
+use std::path::Path;
 
-#[cfg(feature = "storage")]
-pub(crate) mod disk_storage;
 pub mod edge_filter;
 pub mod list_ops;
 pub mod materialize;
@@ -15,4 +14,8 @@ impl InternalStorageOps for GraphStorage {
     fn get_storage(&self) -> Option<&Storage> {
         None
     }
+
+    fn disk_storage_path(&self) -> Option<&Path> {
+        self.disk_storage_path()
+    }
 }
diff --git a/raphtory/src/db/api/storage/graph/storage_ops/time_props.rs b/raphtory/src/db/api/storage/graph/storage_ops/time_props.rs
index 67c4bf3389..e9f80e4682 100644
--- a/raphtory/src/db/api/storage/graph/storage_ops/time_props.rs
+++ b/raphtory/src/db/api/storage/graph/storage_ops/time_props.rs
@@ -1,5 +1,3 @@
-use std::ops::Deref;
-
 use super::GraphStorage;
 use crate::{
     core::utils::iter::GenLockedIter,
@@ -16,57 +14,85 @@ use raphtory_api::{
     },
     iter::IntoDynBoxed,
 };
+use storage::api::graph_props::{GraphPropEntryOps, GraphPropRefOps};
 
 impl InternalTemporalPropertyViewOps for GraphStorage {
     fn dtype(&self, id: usize) -> PropType {
-        self.graph_meta().get_temporal_dtype(id).unwrap()
+        self.graph_props_meta()
+            .temporal_prop_mapper()
+            .get_dtype(id)
+            .unwrap()
     }
 
     fn temporal_iter(&self, id: usize) -> BoxedLIter<'_, (EventTime, Prop)> {
-        self.graph_meta()
-            .get_temporal_prop(id)
-            .into_iter()
-            .flat_map(|prop| GenLockedIter::from(prop, |prop| prop.deref().iter().into_dyn_boxed()))
-            .into_dyn_boxed()
+        let graph_entry = self.graph_entry();
+
+        // Return a boxed iterator of temporal props over the locked graph entry.
+        let iter = GenLockedIter::from(graph_entry, |entry| {
+            entry.as_ref().get_temporal_prop(id).iter().into_dyn_boxed()
+        });
+
+        iter.into_dyn_boxed()
     }
 
     fn temporal_iter_rev(&self, id: usize) -> BoxedLIter<'_, (EventTime, Prop)> {
-        self.graph_meta()
-            .get_temporal_prop(id)
-            .into_iter()
-            .flat_map(|prop| {
-                GenLockedIter::from(prop, |prop| prop.deref().iter().rev().into_dyn_boxed())
-            })
-            .into_dyn_boxed()
+        let graph_entry = self.graph_entry();
+
+        // Return a boxed iterator of temporal props in reverse order over
+        // the locked graph entry.
+        let iter = GenLockedIter::from(graph_entry, |entry| {
+            entry
+                .as_ref()
+                .get_temporal_prop(id)
+                .iter_inner_rev(None)
+                .into_dyn_boxed()
+        });
+
+        iter.into_dyn_boxed()
     }
 
     fn temporal_value(&self, id: usize) -> Option<Prop> {
-        self.graph_meta()
+        let graph_entry = self.graph_entry();
+
+        graph_entry
+            .as_ref()
             .get_temporal_prop(id)
-            .and_then(|prop| prop.deref().last_before(EventTime::MAX).map(|(_, v)| v))
+            .last_before(EventTime::MAX)
+            .map(|(_, prop)| prop)
     }
 
     fn temporal_value_at(&self, id: usize, t: EventTime) -> Option<Prop> {
-        self.graph_meta()
+        let graph_entry = self.graph_entry();
+
+        graph_entry
+            .as_ref()
             .get_temporal_prop(id)
-            .and_then(|prop| prop.deref().last_before(t.next()).map(|(_, v)| v))
+            .last_before(t.next())
+            .map(|(_, prop)| prop)
     }
 }
 
 impl InternalTemporalPropertiesOps for GraphStorage {
     fn get_temporal_prop_id(&self, name: &str) -> Option<usize> {
-        self.graph_meta().get_temporal_id(name)
+        self.graph_props_meta().temporal_prop_mapper().get_id(name)
     }
 
     fn get_temporal_prop_name(&self, id: usize) -> ArcStr {
-        self.graph_meta().get_temporal_name(id)
+        self.graph_props_meta().temporal_prop_mapper().get_name(id)
     }
 
     fn temporal_prop_ids(&self) -> BoxedLIter<'_, usize> {
-        Box::new(self.graph_meta().temporal_ids())
+        self.graph_props_meta()
+            .temporal_prop_mapper()
+            .ids()
+            .into_dyn_boxed()
     }
 
     fn temporal_prop_keys(&self) -> BoxedLIter<'_, ArcStr> {
-        Box::new(self.graph_meta().temporal_names().into_iter())
+        self.graph_props_meta()
+            .temporal_prop_mapper()
+            .keys()
+            .into_iter()
+            .into_dyn_boxed()
     }
 }
diff --git a/raphtory/src/db/api/storage/graph/storage_ops/time_semantics.rs b/raphtory/src/db/api/storage/graph/storage_ops/time_semantics.rs
index b877f9bb39..09516f2008 100644
--- a/raphtory/src/db/api/storage/graph/storage_ops/time_semantics.rs
+++ b/raphtory/src/db/api/storage/graph/storage_ops/time_semantics.rs
@@ -1,16 +1,21 @@
 use super::GraphStorage;
 use crate::{
-    core::{storage::timeindex::TimeIndexOps, utils::iter::GenLockedDIter},
+    core::storage::timeindex::TimeIndexOps,
     db::api::view::internal::{GraphTimeSemanticsOps, TimeSemantics},
     prelude::Prop,
 };
 use raphtory_api::{
     core::{entities::properties::tprop::TPropOps, storage::timeindex::EventTime},
-    iter::{BoxedLDIter, IntoDynDBoxed},
+    iter::{BoxedLIter, IntoDynBoxed},
 };
-use raphtory_storage::graph::nodes::node_storage_ops::NodeStorageOps;
+use raphtory_core::utils::iter::GenLockedIter;
+use raphtory_storage::graph::{locked::LockedGraph, nodes::node_storage_ops::NodeStorageOps};
 use rayon::iter::ParallelIterator;
-use std::ops::{Deref, Range};
+use std::ops::Range;
+use storage::{
+    api::graph_props::{GraphPropEntryOps, GraphPropRefOps},
+    gen_ts::ALL_LAYERS,
+};
 
 impl GraphTimeSemanticsOps for GraphStorage {
     fn node_time_semantics(&self) -> TimeSemantics {
@@ -32,56 +37,78 @@ impl GraphTimeSemanticsOps for GraphStorage {
     #[inline]
     fn earliest_time_global(&self) -> Option<i64> {
         match self {
-            GraphStorage::Mem(storage) => storage.graph.graph_earliest_time(),
-            GraphStorage::Unlocked(storage) => storage.graph_earliest_time(),
-            #[cfg(feature = "storage")]
-            GraphStorage::Disk(storage) => storage.inner.earliest(),
+            GraphStorage::Mem(LockedGraph { graph, .. }) | GraphStorage::Unlocked(graph) => {
+                graph.graph_earliest_time()
+            }
         }
     }
 
     #[inline]
     fn latest_time_global(&self) -> Option<i64> {
         match self {
-            GraphStorage::Mem(storage) => storage.graph.graph_latest_time(),
-            GraphStorage::Unlocked(storage) => storage.graph_latest_time(),
-            #[cfg(feature = "storage")]
-            GraphStorage::Disk(storage) => storage.inner.latest(),
+            GraphStorage::Mem(LockedGraph { graph, .. }) | GraphStorage::Unlocked(graph) => {
+                graph.graph_latest_time()
+            }
         }
     }
 
     fn earliest_time_window(&self, start: EventTime, end: EventTime) -> Option<i64> {
         self.nodes()
             .par_iter()
-            .flat_map(|node| node.additions().range(start..end).first_t())
+            .flat_map_iter(|node| {
+                node.additions()
+                    .range(start..end)
+                    .first_t()
+                    .into_iter()
+                    .chain(
+                        node.node_edge_additions(ALL_LAYERS.clone())
+                            .range(start..end)
+                            .first_t(),
+                    )
+            })
             .min()
     }
 
     fn latest_time_window(&self, start: EventTime, end: EventTime) -> Option<i64> {
         self.nodes()
             .par_iter()
-            .flat_map(|node| node.additions().range(start..end).last_t())
+            .flat_map_iter(|node| {
+                node.additions()
+                    .range(start..end)
+                    .last_t()
+                    .into_iter()
+                    .chain(
+                        node.node_edge_additions(ALL_LAYERS.clone())
+                            .range(start..end)
+                            .last_t(),
+                    )
+            })
             .max()
     }
 
     fn has_temporal_prop(&self, prop_id: usize) -> bool {
-        prop_id < self.graph_meta().temporal_mapper().len()
+        self.graph_props_meta()
+            .temporal_prop_mapper()
+            .has_id(prop_id)
     }
 
-    fn temporal_prop_iter(&self, prop_id: usize) -> BoxedLDIter<'_, (EventTime, Prop)> {
-        self.graph_meta()
-            .get_temporal_prop(prop_id)
-            .into_iter()
-            .flat_map(move |prop| {
-                GenLockedDIter::from(prop, |prop| prop.deref().iter().into_dyn_dboxed())
-            })
-            .into_dyn_dboxed()
+    fn temporal_prop_iter(&self, prop_id: usize) -> BoxedLIter<'_, (EventTime, Prop)> {
+        let graph_entry = self.graph_entry();
+
+        GenLockedIter::from(graph_entry, |entry| {
+            entry
+                .as_ref()
+                .get_temporal_prop(prop_id)
+                .iter()
+                .into_dyn_boxed()
+        })
+        .into_dyn_boxed()
     }
 
     fn has_temporal_prop_window(&self, prop_id: usize, w: Range<EventTime>) -> bool {
-        self.graph_meta()
-            .get_temporal_prop(prop_id)
-            .filter(|p| p.deref().iter_window(w).next().is_some())
-            .is_some()
+        let graph_entry = self.graph_entry();
+
+        graph_entry.as_ref().get_temporal_prop(prop_id).active(w)
     }
 
     fn temporal_prop_iter_window(
@@ -89,22 +116,44 @@ impl GraphTimeSemanticsOps for GraphStorage {
         prop_id: usize,
         start: EventTime,
         end: EventTime,
-    ) -> BoxedLDIter<'_, (EventTime, Prop)> {
-        self.graph_meta()
-            .get_temporal_prop(prop_id)
-            .into_iter()
-            .flat_map(move |prop| {
-                GenLockedDIter::from(prop, |prop| {
-                    prop.deref().iter_window(start..end).into_dyn_dboxed()
-                })
-            })
-            .into_dyn_dboxed()
+    ) -> BoxedLIter<'_, (EventTime, Prop)> {
+        let graph_entry = self.graph_entry();
+
+        GenLockedIter::from(graph_entry, move |entry| {
+            entry
+                .as_ref()
+                .get_temporal_prop(prop_id)
+                .iter_window(start..end)
+                .into_dyn_boxed()
+        })
+        .into_dyn_boxed()
+    }
+
+    fn temporal_prop_iter_window_rev(
+        &self,
+        prop_id: usize,
+        start: EventTime,
+        end: EventTime,
+    ) -> BoxedLIter<'_, (EventTime, Prop)> {
+        let graph_entry = self.graph_entry();
+
+        GenLockedIter::from(graph_entry, move |entry| {
+            entry
+                .as_ref()
+                .get_temporal_prop(prop_id)
+                .iter_window_rev(start..end)
+                .into_dyn_boxed()
+        })
+        .into_dyn_boxed()
     }
 
     fn temporal_prop_last_at(&self, prop_id: usize, t: EventTime) -> Option<(EventTime, Prop)> {
-        self.graph_meta()
+        let graph_entry = self.graph_entry();
+
+        graph_entry
+            .as_ref()
             .get_temporal_prop(prop_id)
-            .and_then(|p| p.deref().last_before(t.next()))
+            .last_before(t.next())
     }
 
     fn temporal_prop_last_at_window(
@@ -114,18 +163,20 @@ impl GraphTimeSemanticsOps for GraphStorage {
         w: Range<EventTime>,
     ) -> Option<(EventTime, Prop)> {
         if w.contains(&t) {
-            self.graph_meta().get_temporal_prop(prop_id).and_then(|p| {
-                p.deref()
-                    .last_before(t.next())
-                    .filter(|(t, _)| w.contains(t))
-            })
+            let graph_entry = self.graph_entry();
+
+            graph_entry
+                .as_ref()
+                .get_temporal_prop(prop_id)
+                .last_before(t.next())
+                .filter(|(prop_time, _)| w.contains(prop_time))
         } else {
             None
         }
     }
 }
 
-#[cfg(test)]
+#[cfg(all(test, feature = "search"))]
 mod test_graph_storage {
     use crate::{db::api::view::StaticGraphViewOps, prelude::AdditionOps};
     use raphtory_api::core::entities::properties::prop::Prop;
@@ -149,7 +200,7 @@ mod test_graph_storage {
         ];
 
         for (id, name, props) in nodes {
-            graph.add_node(id, name, props, None).unwrap();
+            graph.add_node(id, name, props, None, None).unwrap();
         }
 
         graph
@@ -183,7 +234,6 @@ mod test_graph_storage {
         graph
     }
 
-    #[cfg(all(test, feature = "search"))]
     mod search_nodes {
         use super::*;
         use crate::{
@@ -215,7 +265,6 @@ mod test_graph_storage {
         }
     }
 
-    #[cfg(all(test, feature = "search"))]
     mod search_edges {
         use super::*;
         use crate::{
@@ -230,6 +279,7 @@ mod test_graph_storage {
         };
 
         #[test]
+        #[ignore = "TODO: #2372"]
         fn test_search_edges_latest() {
             let g = Graph::new();
             let g = init_graph_for_edges_tests(g);
diff --git a/raphtory/src/db/api/storage/storage.rs b/raphtory/src/db/api/storage/storage.rs
index 631e8fc5c7..6aba8cfb92 100644
--- a/raphtory/src/db/api/storage/storage.rs
+++ b/raphtory/src/db/api/storage/storage.rs
@@ -1,63 +1,68 @@
-#[cfg(feature = "search")]
-use crate::search::graph_index::GraphIndex;
 use crate::{
-    core::entities::{graph::tgraph::TemporalGraph, nodes::node_ref::NodeRef},
+    core::entities::nodes::node_ref::NodeRef,
     db::api::view::{
         internal::{InheritEdgeHistoryFilter, InheritNodeHistoryFilter, InternalStorageOps},
         Base, InheritViewOps,
     },
+    errors::{into_graph_err, GraphError},
 };
-use parking_lot::{RwLock, RwLockWriteGuard};
+use db4_graph::{TemporalGraph, WriteLockedGraph};
 use raphtory_api::core::{
-    entities::{EID, VID},
+    entities::{
+        properties::{
+            meta::Meta,
+            prop::{AsPropRef, Prop, PropType},
+        },
+        GidRef, LayerId, EID, VID,
+    },
     storage::{dict_mapper::MaybeNew, timeindex::EventTime},
 };
-use raphtory_storage::graph::graph::GraphStorage;
-use serde::{Deserialize, Serialize};
-use std::{
-    fmt::{Display, Formatter},
-    ops::{Deref, DerefMut},
-    sync::Arc,
-};
-use tracing::info;
-
-#[cfg(feature = "search")]
-use crate::search::graph_index::MutableGraphIndex;
-use crate::{db::api::view::IndexSpec, errors::GraphError};
-use raphtory_api::core::entities::{
-    properties::prop::{Prop, PropType},
-    GidRef,
-};
-use raphtory_core::storage::{
-    raw_edges::{EdgeWGuard, WriteLockedEdges},
-    EntryMut, NodeSlot, WriteLockedNodes,
-};
 use raphtory_storage::{
     core_ops::InheritCoreGraphOps,
-    graph::{locked::WriteLockedGraph, nodes::node_storage_ops::NodeStorageOps},
+    graph::graph::GraphStorage,
     layer_ops::InheritLayerOps,
     mutation::{
-        addition_ops::InternalAdditionOps, deletion_ops::InternalDeletionOps,
+        addition_ops::{EdgeWriteLock, InternalAdditionOps, SessionAdditionOps},
+        addition_ops_ext::{AtomicAddEdge, AtomicAddNode, UnlockedSession},
         property_addition_ops::InternalPropertyAdditionOps,
+        EdgeWriterT, GraphPropWriterT, NodeWriterT,
     },
+    recovery_ops::RecoveryOps,
 };
-#[cfg(feature = "proto")]
+use std::{
+    fmt::{Display, Formatter},
+    path::Path,
+    sync::Arc,
+};
+use storage::wal::LSN;
+
+#[cfg(feature = "search")]
 use {
-    crate::serialise::incremental::{GraphWriter, InternalCache},
-    crate::serialise::GraphFolder,
-    once_cell::sync::OnceCell,
+    crate::{
+        db::api::view::IndexSpec,
+        search::graph_index::{GraphIndex, MutableGraphIndex},
+        serialise::{GraphFolder, GraphPaths},
+    },
+    either::Either,
+    parking_lot::RwLock,
+    raphtory_api::core::entities::properties::prop::IntoProp,
+    raphtory_storage::core_ops::CoreGraphOps,
+    std::{
+        io::{Seek, Write},
+        ops::{Deref, DerefMut},
+    },
+    tracing::info,
+    zip::ZipWriter,
 };
 
-#[derive(Debug, Default, Serialize, Deserialize)]
+// Re-export for raphtory dependencies to use when creating graphs.
+pub use storage::{persist::strategy::PersistenceStrategy, Config, Extension};
+
+#[derive(Debug, Default)]
 pub struct Storage {
     graph: GraphStorage,
-    #[cfg(feature = "proto")]
-    #[serde(skip)]
-    pub(crate) cache: OnceCell<GraphWriter>,
     #[cfg(feature = "search")]
-    #[serde(skip)]
     pub(crate) index: RwLock<GraphIndex>,
-    // vector index
 }
 
 impl From<GraphStorage> for Storage {
@@ -88,34 +93,85 @@ impl Base for Storage {
 const IN_MEMORY_INDEX_NOT_PERSISTED: &str = "In-memory index not persisted. Not supported";
 
 impl Storage {
-    pub(crate) fn new(num_locks: usize) -> Self {
+    pub(crate) fn new() -> Self {
         Self {
-            graph: GraphStorage::Unlocked(Arc::new(TemporalGraph::new(num_locks))),
-            #[cfg(feature = "proto")]
-            cache: OnceCell::new(),
+            graph: GraphStorage::Unlocked(Arc::new(TemporalGraph::default())),
             #[cfg(feature = "search")]
             index: RwLock::new(GraphIndex::Empty),
         }
     }
 
+    pub(crate) fn new_at_path(path: impl AsRef<Path>) -> Result<Self, GraphError> {
+        let config = Config::default();
+        let ext = Extension::new(config, Some(path.as_ref()))?;
+        let temporal_graph = TemporalGraph::new_at_path_with_ext(path, ext)?;
+
+        Ok(Self {
+            graph: GraphStorage::Unlocked(Arc::new(temporal_graph)),
+            #[cfg(feature = "search")]
+            index: RwLock::new(GraphIndex::Empty),
+        })
+    }
+
+    pub(crate) fn new_with_config(config: Config) -> Result<Self, GraphError> {
+        let ext = Extension::new(config, None)?;
+        let temporal_graph = TemporalGraph::new(ext)?;
+        Ok(Self {
+            graph: GraphStorage::Unlocked(Arc::new(temporal_graph)),
+            #[cfg(feature = "search")]
+            index: RwLock::new(GraphIndex::Empty),
+        })
+    }
+
+    pub(crate) fn new_at_path_with_config(
+        path: impl AsRef<Path>,
+        config: Config,
+    ) -> Result<Self, GraphError> {
+        let ext = Extension::new(config, Some(path.as_ref()))?;
+        let temporal_graph = TemporalGraph::new_at_path_with_ext(path, ext)?;
+
+        Ok(Self {
+            graph: GraphStorage::Unlocked(Arc::new(temporal_graph)),
+            #[cfg(feature = "search")]
+            index: RwLock::new(GraphIndex::Empty),
+        })
+    }
+
+    fn load_with_extension(path: &Path, ext: Extension) -> Result<Self, GraphError> {
+        let temporal_graph = TemporalGraph::load(path, ext)?;
+
+        // Run crash recovery if needed.
+        temporal_graph.run_recovery()?;
+
+        Ok(Self {
+            graph: GraphStorage::Unlocked(Arc::new(temporal_graph)),
+            #[cfg(feature = "search")]
+            index: RwLock::new(GraphIndex::Empty),
+        })
+    }
+
+    pub fn load(path: impl AsRef<Path>) -> Result<Self, GraphError> {
+        let path = path.as_ref();
+        let ext = Extension::load(path)?;
+
+        Self::load_with_extension(path, ext)
+    }
+
+    pub fn load_with_config(path: impl AsRef<Path>, config: Config) -> Result<Self, GraphError> {
+        let path = path.as_ref();
+        let ext = Extension::load_with_config(path, config)?;
+
+        Self::load_with_extension(path, ext)
+    }
+
     pub(crate) fn from_inner(graph: GraphStorage) -> Self {
         Self {
             graph,
-            #[cfg(feature = "proto")]
-            cache: OnceCell::new(),
             #[cfg(feature = "search")]
             index: RwLock::new(GraphIndex::Empty),
         }
     }
 
-    #[cfg(feature = "proto")]
-    #[inline]
-    fn if_cache(&self, map_fn: impl FnOnce(&GraphWriter)) {
-        if let Some(cache) = self.cache.get() {
-            map_fn(cache)
-        }
-    }
-
     #[cfg(feature = "search")]
     #[inline]
     fn if_index(
@@ -179,8 +235,7 @@ impl Storage {
                     drop(guard);
                     let mut guard = self.index.write();
                     if let e @ GraphIndex::Empty = guard.deref_mut() {
-                        let cached_graph_path = self.get_cache().map(|cache| cache.folder.clone());
-                        let index = GraphIndex::create(&self.graph, false, cached_graph_path)?;
+                        let index = GraphIndex::create(&self.graph, false, None)?;
                         *e = index;
                     }
                 }
@@ -224,7 +279,7 @@ impl Storage {
         self.index.read_recursive().is_indexed()
     }
 
-    pub(crate) fn persist_index_to_disk(&self, path: &GraphFolder) -> Result<(), GraphError> {
+    pub(crate) fn persist_index_to_disk(&self, path: &impl GraphPaths) -> Result<(), GraphError> {
         let guard = self.get_index().read_recursive();
         if guard.is_indexed() {
             if guard.path().is_none() {
@@ -236,14 +291,18 @@ impl Storage {
         Ok(())
     }
 
-    pub(crate) fn persist_index_to_disk_zip(&self, path: &GraphFolder) -> Result<(), GraphError> {
+    pub(crate) fn persist_index_to_disk_zip<W: Write + Seek>(
+        &self,
+        writer: &mut ZipWriter<W>,
+        prefix: &str,
+    ) -> Result<(), GraphError> {
         let guard = self.get_index().read_recursive();
         if guard.is_indexed() {
             if guard.path().is_none() {
                 info!("{}", IN_MEMORY_INDEX_NOT_PERSISTED);
                 return Ok(());
             }
-            self.if_index(|index| index.persist_to_disk_zip(path))?;
+            self.if_index(|index| index.persist_to_disk_zip(writer, prefix))?;
         }
         Ok(())
     }
@@ -259,6 +318,10 @@ impl InternalStorageOps for Storage {
     fn get_storage(&self) -> Option<&Storage> {
         Some(self)
     }
+
+    fn disk_storage_path(&self) -> Option<&Path> {
+        self.graph.disk_storage_path()
+    }
 }
 
 impl InheritNodeHistoryFilter for Storage {}
@@ -266,71 +329,73 @@ impl InheritEdgeHistoryFilter for Storage {}
 
 impl InheritViewOps for Storage {}
 
-impl InternalAdditionOps for Storage {
-    type Error = GraphError;
+#[derive(Clone)]
+pub struct StorageWriteSession<'a> {
+    session: UnlockedSession<'a>,
+    storage: &'a Storage,
+}
 
-    fn write_lock(&self) -> Result<WriteLockedGraph<'_>, Self::Error> {
-        Ok(self.graph.write_lock()?)
-    }
+pub struct AtomicAddEdgeSession<'a> {
+    session: AtomicAddEdge<'a, Extension>,
+    storage: &'a Storage,
+}
 
-    fn write_lock_nodes(&self) -> Result<WriteLockedNodes<'_>, Self::Error> {
-        Ok(self.graph.write_lock_nodes()?)
+impl EdgeWriteLock for AtomicAddEdgeSession<'_> {
+    fn internal_add_update(
+        &mut self,
+        t: EventTime,
+        layer: LayerId,
+        props: impl IntoIterator<Item = (usize, Prop)>,
+    ) {
+        self.session.internal_add_update(t, layer, props)
     }
 
-    fn write_lock_edges(&self) -> Result<WriteLockedEdges<'_>, Self::Error> {
-        Ok(self.graph.write_lock_edges()?)
+    fn internal_delete_edge(&mut self, t: EventTime, layer: LayerId) {
+        self.session.internal_delete_edge(t, layer)
     }
 
-    fn next_event_id(&self) -> Result<usize, Self::Error> {
-        Ok(self.graph.next_event_id()?)
+    fn set_lsn(&mut self, lsn: LSN) {
+        self.session.set_lsn(lsn);
     }
 
-    fn reserve_event_ids(&self, num_ids: usize) -> Result<usize, Self::Error> {
-        Ok(self.graph.reserve_event_ids(num_ids)?)
+    fn src(&self) -> MaybeNew<VID> {
+        self.session.src()
     }
 
-    fn resolve_layer(&self, layer: Option<&str>) -> Result<MaybeNew<usize>, GraphError> {
-        let id = self.graph.resolve_layer(layer)?;
-
-        #[cfg(feature = "proto")]
-        self.if_cache(|cache| cache.resolve_layer(layer, id));
+    fn dst(&self) -> MaybeNew<VID> {
+        self.session.dst()
+    }
 
-        Ok(id)
+    fn eid(&self) -> MaybeNew<EID> {
+        self.session.eid()
     }
+}
 
-    fn resolve_node(&self, id: NodeRef) -> Result<MaybeNew<VID>, GraphError> {
-        match id {
-            NodeRef::Internal(id) => Ok(MaybeNew::Existing(id)),
-            NodeRef::External(gid) => {
-                let id = self.graph.resolve_node(id)?;
+impl<'a> SessionAdditionOps for StorageWriteSession<'a> {
+    type Error = GraphError;
 
-                #[cfg(feature = "proto")]
-                self.if_cache(|cache| cache.resolve_node(id, gid));
+    fn read_event_id(&self) -> Result<usize, Self::Error> {
+        Ok(self.session.read_event_id()?)
+    }
 
-                Ok(id)
-            }
-        }
+    fn set_event_id(&self, event_id: usize) -> Result<(), Self::Error> {
+        Ok(self.session.set_event_id(event_id)?)
     }
 
-    fn set_node(&self, gid: GidRef, vid: VID) -> Result<(), Self::Error> {
-        Ok(self.graph.set_node(gid, vid)?)
+    fn next_event_id(&self) -> Result<usize, Self::Error> {
+        Ok(self.session.next_event_id()?)
     }
 
-    fn resolve_node_and_type(
-        &self,
-        id: NodeRef,
-        node_type: &str,
-    ) -> Result<MaybeNew<(MaybeNew<VID>, MaybeNew<usize>)>, GraphError> {
-        let node_and_type = self.graph.resolve_node_and_type(id, node_type)?;
+    fn reserve_event_ids(&self, num_ids: usize) -> Result<usize, Self::Error> {
+        Ok(self.session.reserve_event_ids(num_ids)?)
+    }
 
-        #[cfg(feature = "proto")]
-        self.if_cache(|cache| {
-            let (vid, _) = node_and_type.inner();
-            let node_entry = self.graph.core_node(vid.inner());
-            cache.resolve_node_and_type(node_and_type, node_type, node_entry.id())
-        });
+    fn set_max_event_id(&self, value: usize) -> Result<usize, Self::Error> {
+        Ok(self.session.set_max_event_id(value)?)
+    }
 
-        Ok(node_and_type)
+    fn set_node(&self, gid: GidRef, vid: VID) -> Result<(), Self::Error> {
+        Ok(self.session.set_node(gid, vid)?)
     }
 
     fn resolve_graph_property(
@@ -338,14 +403,11 @@ impl InternalAdditionOps for Storage {
         prop: &str,
         dtype: PropType,
         is_static: bool,
-    ) -> Result<MaybeNew<usize>, GraphError> {
+    ) -> Result<MaybeNew<usize>, Self::Error> {
         let id = self
-            .graph
+            .session
             .resolve_graph_property(prop, dtype.clone(), is_static)?;
 
-        #[cfg(feature = "proto")]
-        self.if_cache(|cache| cache.resolve_graph_property(prop, id, dtype, is_static));
-
         Ok(id)
     }
 
@@ -354,14 +416,11 @@ impl InternalAdditionOps for Storage {
         prop: &str,
         dtype: PropType,
         is_static: bool,
-    ) -> Result<MaybeNew<usize>, GraphError> {
+    ) -> Result<MaybeNew<usize>, Self::Error> {
         let id = self
-            .graph
+            .session
             .resolve_node_property(prop, dtype.clone(), is_static)?;
 
-        #[cfg(feature = "proto")]
-        self.if_cache(|cache| cache.resolve_node_property(prop, id, &dtype, is_static));
-
         Ok(id)
     }
 
@@ -370,122 +429,185 @@ impl InternalAdditionOps for Storage {
         prop: &str,
         dtype: PropType,
         is_static: bool,
-    ) -> Result<MaybeNew<usize>, GraphError> {
+    ) -> Result<MaybeNew<usize>, Self::Error> {
         let id = self
-            .graph
+            .session
             .resolve_edge_property(prop, dtype.clone(), is_static)?;
 
-        #[cfg(feature = "proto")]
-        self.if_cache(|cache| cache.resolve_edge_property(prop, id, &dtype, is_static));
-
         Ok(id)
     }
+}
 
-    fn internal_add_node(
-        &self,
-        t: EventTime,
-        v: VID,
-        props: &[(usize, Prop)],
-    ) -> Result<(), GraphError> {
-        self.graph.internal_add_node(t, v, props)?;
+impl InternalAdditionOps for Storage {
+    type Error = GraphError;
 
-        #[cfg(feature = "proto")]
-        self.if_cache(|cache| cache.add_node_update(t, v, props));
+    type WS<'a> = StorageWriteSession<'a>;
+    type AtomicAddEdge<'a> = AtomicAddEdgeSession<'a>;
 
-        #[cfg(feature = "search")]
-        self.if_index_mut(|index| index.add_node_update(&self.graph, t, MaybeNew::New(v), props))?;
+    fn write_lock(&self) -> Result<WriteLockedGraph<'_, Extension>, Self::Error> {
+        Ok(self.graph.write_lock()?)
+    }
 
-        Ok(())
+    fn resolve_layer(&self, layer: Option<&str>) -> Result<MaybeNew<LayerId>, Self::Error> {
+        let id = self.graph.resolve_layer(layer)?;
+        Ok(id)
     }
 
-    fn internal_add_edge(
-        &self,
-        t: EventTime,
-        src: VID,
-        dst: VID,
-        props: &[(usize, Prop)],
-        layer: usize,
-    ) -> Result<MaybeNew<EID>, GraphError> {
-        let id = self.graph.internal_add_edge(t, src, dst, props, layer)?;
+    fn resolve_node(&self, id: NodeRef) -> Result<MaybeNew<VID>, Self::Error> {
+        match id {
+            NodeRef::Internal(id) => Ok(MaybeNew::Existing(id)),
+            NodeRef::External(_) => {
+                let id = self.graph.resolve_node(id)?;
 
-        #[cfg(feature = "proto")]
-        self.if_cache(|cache| {
-            cache.resolve_edge(id, src, dst);
-            cache.add_edge_update(t, id.inner(), props, layer);
-        });
+                Ok(id)
+            }
+        }
+    }
+
+    fn resolve_and_update_node_and_type(
+        &self,
+        id: NodeRef,
+        node_type: Option<&str>,
+    ) -> Result<MaybeNew<(MaybeNew<VID>, MaybeNew<usize>)>, Self::Error> {
+        let node_and_type = self.graph.resolve_and_update_node_and_type(id, node_type)?;
 
         #[cfg(feature = "search")]
-        self.if_index_mut(|index| index.add_edge_update(&self.graph, id, t, layer, props))?;
+        node_and_type
+            .if_new(|(node_id, _)| {
+                let name = match id {
+                    NodeRef::Internal(vid) => self.graph.node_name(vid),
+                    NodeRef::External(gid) => gid.to_string(),
+                };
+                self.if_index_mut(|index| index.add_new_node(node_id.inner(), name, node_type))
+            })
+            .transpose()?;
 
-        Ok(id)
+        Ok(node_and_type)
+    }
+
+    fn write_session(&self) -> Result<Self::WS<'_>, Self::Error> {
+        let session = self.graph.write_session()?;
+        Ok(StorageWriteSession {
+            session,
+            storage: self,
+        })
     }
 
-    fn internal_add_edge_update(
+    fn atomic_add_edge(
         &self,
-        t: EventTime,
-        edge: EID,
-        props: &[(usize, Prop)],
-        layer: usize,
-    ) -> Result<(), GraphError> {
-        self.graph.internal_add_edge_update(t, edge, props, layer)?;
+        src: NodeRef,
+        dst: NodeRef,
+        e_id: Option<EID>,
+    ) -> Result<Self::AtomicAddEdge<'_>, Self::Error> {
+        let session = self.graph.atomic_add_edge(src, dst, e_id)?;
+        Ok(AtomicAddEdgeSession {
+            session,
+            storage: self,
+        })
+    }
 
-        #[cfg(feature = "proto")]
-        self.if_cache(|cache| cache.add_edge_update(t, edge, props, layer));
+    fn internal_add_node(
+        &self,
+        t: EventTime,
+        v: VID,
+        props: Vec<(usize, Prop)>,
+        layer_id: LayerId,
+    ) -> Result<NodeWriterT<'_>, Self::Error> {
+        #[cfg(feature = "search")]
+        let index_res = self.if_index_mut(|index| index.add_node_update(t, v, &props));
+        // don't fail early on indexing, actually update the graph even if indexing failed
+        let writer = self.graph.internal_add_node(t, v, props, layer_id)?;
 
         #[cfg(feature = "search")]
-        self.if_index_mut(|index| {
-            index.add_edge_update(&self.graph, MaybeNew::Existing(edge), t, layer, props)
-        })?;
+        index_res?;
 
-        Ok(())
+        Ok(writer)
     }
-}
 
-impl InternalPropertyAdditionOps for Storage {
-    type Error = GraphError;
-    fn internal_add_properties(
+    fn validate_props<PN: AsRef<str>>(
         &self,
-        t: EventTime,
-        props: &[(usize, Prop)],
-    ) -> Result<(), GraphError> {
-        self.graph.internal_add_properties(t, props)?;
+        is_static: bool,
+        meta: &Meta,
+        prop: impl Iterator<Item = (PN, Prop)>,
+    ) -> Result<Vec<(usize, Prop)>, Self::Error> {
+        Ok(self.graph.validate_props(is_static, meta, prop)?)
+    }
 
-        #[cfg(feature = "proto")]
-        self.if_cache(|cache| cache.add_graph_tprops(t, props));
+    fn validate_props_with_status<PN: AsRef<str>>(
+        &self,
+        is_static: bool,
+        meta: &Meta,
+        props: impl Iterator<Item = (PN, Prop)>,
+    ) -> Result<Vec<MaybeNew<(PN, usize, Prop)>>, Self::Error> {
+        Ok(self
+            .graph
+            .validate_props_with_status(is_static, meta, props)?)
+    }
 
-        Ok(())
+    fn validate_gids<'a>(
+        &self,
+        gids: impl IntoIterator<Item = GidRef<'a>>,
+    ) -> Result<(), Self::Error> {
+        Ok(self.graph.validate_gids(gids)?)
     }
 
-    fn internal_add_metadata(&self, props: &[(usize, Prop)]) -> Result<(), GraphError> {
-        self.graph.internal_add_metadata(props)?;
+    fn resolve_node_and_type(
+        &self,
+        id: NodeRef,
+        node_type: Option<&str>,
+    ) -> Result<(VID, usize), Self::Error> {
+        Ok(self.graph.resolve_node_and_type(id, node_type)?)
+    }
 
-        #[cfg(feature = "proto")]
-        self.if_cache(|cache| cache.add_graph_cprops(props));
+    unsafe fn bulk_load_resolve_node(&self, id: GidRef<'_>) -> Result<VID, Self::Error> {
+        Ok(self.graph.bulk_load_resolve_node(id)?)
+    }
 
-        Ok(())
+    fn atomic_add_node(&self, node: NodeRef) -> Result<AtomicAddNode<'_>, Self::Error> {
+        self.graph.atomic_add_node(node).map_err(into_graph_err)
     }
+}
 
-    fn internal_update_metadata(&self, props: &[(usize, Prop)]) -> Result<(), GraphError> {
-        self.graph.internal_update_metadata(props)?;
+impl InternalPropertyAdditionOps for Storage {
+    type Error = GraphError;
 
-        #[cfg(feature = "proto")]
-        self.if_cache(|cache| cache.add_graph_cprops(props));
+    fn internal_add_properties<P: AsPropRef>(
+        &self,
+        t: EventTime,
+        props: &[(usize, P)],
+    ) -> Result<GraphPropWriterT<'_>, GraphError> {
+        Ok(self.graph.internal_add_properties(t, props)?)
+    }
 
-        Ok(())
+    fn internal_add_metadata<P: AsPropRef>(
+        &self,
+        props: &[(usize, P)],
+    ) -> Result<GraphPropWriterT<'_>, GraphError> {
+        Ok(self.graph.internal_add_metadata(props)?)
     }
 
-    fn internal_add_node_metadata(
+    fn internal_update_metadata(
         &self,
-        vid: VID,
         props: &[(usize, Prop)],
-    ) -> Result<EntryMut<'_, RwLockWriteGuard<'_, NodeSlot>>, Self::Error> {
-        let lock = self.graph.internal_add_node_metadata(vid, props)?;
+    ) -> Result<GraphPropWriterT<'_>, GraphError> {
+        Ok(self.graph.internal_update_metadata(props)?)
+    }
+
+    fn internal_add_node_metadata<P: AsPropRef>(
+        &self,
+        vid: VID,
+        props: Vec<(usize, P)>,
+    ) -> Result<NodeWriterT<'_>, Self::Error> {
+        #[cfg(feature = "search")]
+        let props_for_index = props
+            .iter()
+            .map(|(id, prop)| (*id, prop.as_prop_ref().into_prop()))
+            .collect::<Vec<_>>();
 
-        #[cfg(feature = "proto")]
-        self.if_cache(|cache| cache.add_node_cprops(vid, props));
+        let lock = self.graph.internal_add_node_metadata(vid, props)?;
 
         #[cfg(feature = "search")]
-        self.if_index_mut(|index| index.add_node_metadata(vid, props))?;
+        self.if_index_mut(|index| index.add_node_metadata(vid, &props_for_index))?;
 
         Ok(lock)
     }
@@ -493,32 +615,37 @@ impl InternalPropertyAdditionOps for Storage {
     fn internal_update_node_metadata(
         &self,
         vid: VID,
-        props: &[(usize, Prop)],
-    ) -> Result<EntryMut<'_, RwLockWriteGuard<'_, NodeSlot>>, Self::Error> {
-        let lock = self.graph.internal_update_node_metadata(vid, props)?;
+        props: Vec<(usize, Prop)>,
+    ) -> Result<NodeWriterT<'_>, Self::Error> {
+        #[cfg(feature = "search")]
+        let props_for_index = props.clone();
 
-        #[cfg(feature = "proto")]
-        self.if_cache(|cache| cache.add_node_cprops(vid, props));
+        let lock = self.graph.internal_update_node_metadata(vid, props)?;
 
         #[cfg(feature = "search")]
-        self.if_index_mut(|index| index.update_node_metadata(vid, props))?;
+        self.if_index_mut(|index| index.update_node_metadata(vid, &props_for_index))?;
 
         Ok(lock)
     }
 
-    fn internal_add_edge_metadata(
+    fn internal_add_edge_metadata<P: AsPropRef>(
         &self,
         eid: EID,
-        layer: usize,
-        props: &[(usize, Prop)],
-    ) -> Result<EdgeWGuard<'_>, Self::Error> {
-        let lock = self.graph.internal_add_edge_metadata(eid, layer, props)?;
+        layer: LayerId,
+        props: Vec<(usize, P)>,
+    ) -> Result<EdgeWriterT<'_>, Self::Error> {
+        // FIXME: this whole thing is not great
 
-        #[cfg(feature = "proto")]
-        self.if_cache(|cache| cache.add_edge_cprops(eid, layer, props));
+        #[cfg(feature = "search")]
+        let props_for_index = props
+            .iter()
+            .map(|(id, prop)| (*id, prop.as_prop_ref().into_prop()))
+            .collect::<Vec<_>>();
+
+        let lock = self.graph.internal_add_edge_metadata(eid, layer, props)?;
 
         #[cfg(feature = "search")]
-        self.if_index_mut(|index| index.add_edge_metadata(eid, layer, props))?;
+        self.if_index_mut(|index| index.add_edge_metadata(eid, layer, &props_for_index))?;
 
         Ok(lock)
     }
@@ -526,54 +653,21 @@ impl InternalPropertyAdditionOps for Storage {
     fn internal_update_edge_metadata(
         &self,
         eid: EID,
-        layer: usize,
-        props: &[(usize, Prop)],
-    ) -> Result<EdgeWGuard<'_>, Self::Error> {
+        layer: LayerId,
+        props: Vec<(usize, Prop)>,
+    ) -> Result<EdgeWriterT<'_>, Self::Error> {
+        // FIXME: this whole thing is not great
+
+        #[cfg(feature = "search")]
+        let props_for_index = props.clone();
+
         let lock = self
             .graph
             .internal_update_edge_metadata(eid, layer, props)?;
 
-        #[cfg(feature = "proto")]
-        self.if_cache(|cache| cache.add_edge_cprops(eid, layer, props));
-
         #[cfg(feature = "search")]
-        self.if_index_mut(|index| index.update_edge_metadata(eid, layer, props))?;
+        self.if_index_mut(|index| index.update_edge_metadata(eid, layer, &props_for_index))?;
 
         Ok(lock)
     }
 }
-
-impl InternalDeletionOps for Storage {
-    type Error = GraphError;
-    fn internal_delete_edge(
-        &self,
-        t: EventTime,
-        src: VID,
-        dst: VID,
-        layer: usize,
-    ) -> Result<MaybeNew<EID>, GraphError> {
-        let eid = self.graph.internal_delete_edge(t, src, dst, layer)?;
-
-        #[cfg(feature = "proto")]
-        self.if_cache(|cache| {
-            cache.resolve_edge(eid, src, dst);
-            cache.delete_edge(eid.inner(), t, layer);
-        });
-
-        Ok(eid)
-    }
-
-    fn internal_delete_existing_edge(
-        &self,
-        t: EventTime,
-        eid: EID,
-        layer: usize,
-    ) -> Result<(), GraphError> {
-        self.graph.internal_delete_existing_edge(t, eid, layer)?;
-
-        #[cfg(feature = "proto")]
-        self.if_cache(|cache| cache.delete_edge(eid, t, layer));
-
-        Ok(())
-    }
-}
diff --git a/raphtory/src/db/api/view/edge.rs b/raphtory/src/db/api/view/edge.rs
index 675e8b5f9e..ca59ee9073 100644
--- a/raphtory/src/db/api/view/edge.rs
+++ b/raphtory/src/db/api/view/edge.rs
@@ -502,17 +502,17 @@ impl<'graph, E: BaseEdgeViewOps<'graph>> EdgeViewOps<'graph> for E {
     fn layer_names(&self) -> Self::ValueType<Vec<ArcStr>> {
         self.map(|g, e| {
             if edge_valid_layer(g, e) {
-                let layer_names = g.edge_meta().layer_meta().get_keys();
+                let layer_names = g.edge_meta().layer_meta().all_keys();
                 match e.layer() {
                     None => {
                         let time_semantics = g.edge_time_semantics();
                         time_semantics
                             .edge_layers(g.core_edge(e.pid()).as_ref(), g, g.layer_ids())
-                            .map(|layer| layer_names[layer].clone())
+                            .map(|layer| layer_names[layer.0].clone())
                             .collect()
                     }
                     Some(l) => {
-                        vec![layer_names[l].clone()]
+                        vec![layer_names[l.0].clone()]
                     }
                 }
             } else {
diff --git a/raphtory/src/db/api/view/graph.rs b/raphtory/src/db/api/view/graph.rs
index dbe0655164..73c935c7c4 100644
--- a/raphtory/src/db/api/view/graph.rs
+++ b/raphtory/src/db/api/view/graph.rs
@@ -1,11 +1,11 @@
-#[cfg(feature = "search")]
-use crate::search::{fallback_filter_edges, fallback_filter_exploded_edges, fallback_filter_nodes};
+#[cfg(feature = "io")]
+use crate::serialise::GraphPaths;
 use crate::{
-    core::entities::{graph::tgraph::TemporalGraph, nodes::node_ref::AsNodeRef, LayerIds, VID},
+    core::entities::{nodes::node_ref::AsNodeRef, LayerIds, VID},
     db::{
         api::{
             properties::{internal::InternalMetadataOps, Metadata, Properties},
-            state::ops::filter::NodeTypeFilterOp,
+            state::{ops::filter::NodeTypeFilterOp, Index},
             view::{internal::*, *},
         },
         graph::{
@@ -14,10 +14,8 @@ use crate::{
             node::NodeView,
             nodes::Nodes,
             views::{
-                cached_view::CachedView,
-                filter::{model::TryAsCompositeFilter, node_filtered_graph::NodeFilteredGraph},
-                node_subgraph::NodeSubgraph,
-                valid_graph::ValidGraph,
+                cached_view::CachedView, filter::node_filtered_graph::NodeFilteredGraph,
+                node_subgraph::NodeSubgraph, valid_graph::ValidGraph,
             },
         },
     },
@@ -25,10 +23,15 @@ use crate::{
     prelude::*,
 };
 use ahash::HashSet;
+use db4_graph::TemporalGraph;
+use itertools::Itertools;
 use raphtory_api::{
     atomic_extra::atomic_usize_from_mut_slice,
     core::{
-        entities::{properties::meta::PropMapper, EID},
+        entities::{
+            properties::meta::{Meta, PropMapper, STATIC_GRAPH_LAYER_ID},
+            LayerId, EID,
+        },
         storage::{arc_str::ArcStr, timeindex::EventTime},
         Direction,
     },
@@ -39,17 +42,29 @@ use raphtory_storage::{
         edges::edge_storage_ops::EdgeStorageOps, graph::GraphStorage,
         nodes::node_storage_ops::NodeStorageOps,
     },
-    mutation::{addition_ops::InternalAdditionOps, MutationError},
+    mutation::{
+        addition_ops::{InternalAdditionOps, SessionAdditionOps},
+        MutationError,
+    },
 };
 use rayon::prelude::*;
 use rustc_hash::FxHashSet;
-use std::sync::{atomic::Ordering, Arc};
+use std::{
+    path::Path,
+    sync::{atomic::Ordering, Arc},
+};
+use storage::{persist::strategy::PersistenceStrategy, Config, Extension};
+
+#[cfg(feature = "search")]
+use crate::{
+    db::graph::views::filter::model::TryAsCompositeFilter,
+    search::{fallback_filter_edges, fallback_filter_exploded_edges, fallback_filter_nodes},
+};
 
 /// This trait GraphViewOps defines operations for accessing
 /// information about a graph. The trait has associated types
 /// that are used to define the type of the nodes, edges
 /// and the corresponding iterators.
-///
 pub trait GraphViewOps<'graph>: BoxableGraphView + Sized + Clone + 'graph {
     /// Return an iterator over all edges in the graph.
     fn edges(&self) -> Edges<'graph, Self>;
@@ -60,10 +75,37 @@ pub trait GraphViewOps<'graph>: BoxableGraphView + Sized + Clone + 'graph {
     /// Return a View of the nodes in the Graph
     fn nodes(&self) -> Nodes<'graph, Self>;
 
-    /// Get a graph clone
+    /// Materializes the view into a new graph.
+    /// If a path is provided, it will be used to store the new graph
+    /// (assuming the storage feature is enabled). Inherits config from the graph.
+    ///
+    /// Arguments:
+    ///     path: Option<&Path>: An optional path used to store the new graph.
     ///
     /// Returns:
-    ///     Graph: Returns clone of the graph
+    ///     MaterializedGraph: Returns a new materialized graph.
+    #[cfg(feature = "io")]
+    fn materialize_at(
+        &self,
+        path: &(impl GraphPaths + ?Sized),
+    ) -> Result<MaterializedGraph, GraphError> {
+        self.materialize_at_with_config(path, self.core_graph().extension().config().clone())
+    }
+
+    /// Materializes the view into a new graph.
+    /// If a path is provided, it will be used to store the new graph
+    /// (assuming the storage feature is enabled). Sets a new config.
+    ///
+    /// # Arguments
+    ///     path: The path for the new graph.
+    ///     config: The new config.
+    #[cfg(feature = "io")]
+    fn materialize_at_with_config(
+        &self,
+        path: &(impl GraphPaths + ?Sized),
+        config: Config,
+    ) -> Result<MaterializedGraph, GraphError>;
+
     fn materialize(&self) -> Result<MaterializedGraph, GraphError>;
 
     fn subgraph<I: IntoIterator<Item = V>, V: AsNodeRef>(&self, nodes: I) -> NodeSubgraph<Self>;
@@ -201,235 +243,396 @@ fn edges_inner<'graph, G: GraphView + 'graph>(g: &G, locked: bool) -> Edges<'gra
     }
 }
 
-impl<'graph, G: GraphView + 'graph> GraphViewOps<'graph> for G {
-    fn edges(&self) -> Edges<'graph, Self> {
-        edges_inner(self, true)
-    }
+fn materialize_impl(
+    graph: &impl GraphView,
+    path: Option<&Path>,
+    config: Config,
+) -> Result<MaterializedGraph, GraphError> {
+    let storage = graph.core_graph().lock();
+    let mut node_meta = Meta::new_for_nodes();
+    let mut edge_meta = Meta::new_for_edges();
+    let mut graph_props_meta = Meta::new_for_graph_props();
+
+    node_meta.set_metadata_mapper(graph.node_meta().metadata_mapper().deep_clone());
+    node_meta.set_temporal_prop_mapper(graph.node_meta().temporal_prop_mapper().deep_clone());
+    edge_meta.set_metadata_mapper(graph.edge_meta().metadata_mapper().deep_clone());
+    edge_meta.set_temporal_prop_mapper(graph.edge_meta().temporal_prop_mapper().deep_clone());
+    graph_props_meta.set_metadata_mapper(graph.graph_props_meta().metadata_mapper().deep_clone());
+    graph_props_meta
+        .set_temporal_prop_mapper(graph.graph_props_meta().temporal_prop_mapper().deep_clone());
+
+    let layer_meta = edge_meta.layer_meta();
+
+    // NOTE: layers must be set in layer_meta before the TemporalGraph is initialized to
+    // make sure empty layers are created.
+    let layer_map: Vec<_> = match graph.layer_ids() {
+        LayerIds::None => {
+            // no layers to map
+            vec![]
+        }
+        LayerIds::All => {
+            let layers = storage.edge_meta().layer_meta().keys();
+            let mut layer_map = vec![0; storage.edge_meta().layer_meta().num_all_fields()];
 
-    fn edges_unlocked(&self) -> Edges<'graph, Self> {
-        edges_inner(self, false)
-    }
+            for (id, name) in storage.edge_meta().layer_meta().ids().zip(layers.iter()) {
+                let new_id = layer_meta.get_or_create_id(name).inner();
+                layer_map[id] = new_id;
+            }
 
-    fn nodes(&self) -> Nodes<'graph, Self> {
-        let graph = self.clone();
-        Nodes::new(graph)
-    }
+            layer_map
+        }
+        LayerIds::One(l_id) => {
+            let mut layer_map = vec![0; storage.edge_meta().layer_meta().num_all_fields()];
+            let layer_name = storage.edge_meta().get_layer_name_by_id(*l_id);
+            let new_id = layer_meta.get_or_create_id(&layer_name).inner();
 
-    fn materialize(&self) -> Result<MaterializedGraph, GraphError> {
-        let storage = self.core_graph().lock();
-        let mut g = TemporalGraph::default();
-
-        // Copy all graph properties
-        g.graph_meta = self.graph_meta().deep_clone();
-
-        // preserve all property mappings
-        g.node_meta
-            .set_metadata_mapper(self.node_meta().metadata_mapper().deep_clone());
-        g.node_meta
-            .set_temporal_prop_meta(self.node_meta().temporal_prop_mapper().deep_clone());
-        g.edge_meta
-            .set_metadata_mapper(self.edge_meta().metadata_mapper().deep_clone());
-        g.edge_meta
-            .set_temporal_prop_meta(self.edge_meta().temporal_prop_mapper().deep_clone());
-
-        let layer_map: Vec<_> = match self.layer_ids() {
-            LayerIds::None => {
-                // no layers to map
-                vec![]
-            }
-            LayerIds::All => {
-                let mut layer_map = vec![0; self.unfiltered_num_layers()];
-                let layers = storage.edge_meta().layer_meta().get_keys();
-                for id in 0..layers.len() {
-                    let new_id = g
-                        .resolve_layer_inner(Some(&layers[id]))
-                        .map_err(MutationError::from)?
-                        .inner();
-                    layer_map[id] = new_id;
-                }
-                layer_map
-            }
-            LayerIds::One(l_id) => {
-                let mut layer_map = vec![0; self.unfiltered_num_layers()];
-                let new_id = g
-                    .resolve_layer_inner(Some(&storage.edge_meta().get_layer_name_by_id(*l_id)))
-                    .map_err(MutationError::from)?;
-                layer_map[*l_id] = new_id.inner();
-                layer_map
+            layer_map[l_id.0] = new_id;
+            layer_map
+        }
+        LayerIds::Multiple(ids) => {
+            let mut layer_map = vec![0; storage.edge_meta().layer_meta().num_all_fields()];
+            let layers = storage.edge_meta().layer_meta().all_keys();
+
+            for id in ids {
+                let layer_name = &layers[id.0];
+                let new_id = layer_meta.get_or_create_id(layer_name).inner();
+                layer_map[id.0] = new_id;
             }
-            LayerIds::Multiple(ids) => {
-                let mut layer_map = vec![0; self.unfiltered_num_layers()];
-                let layers = storage.edge_meta().layer_meta().get_keys();
-                for id in ids {
-                    let new_id = g
-                        .resolve_layer_inner(Some(&layers[id]))
-                        .map_err(MutationError::from)?
-                        .inner();
-                    layer_map[id] = new_id;
-                }
-                layer_map
+
+            layer_map
+        }
+    };
+
+    node_meta.set_layer_mapper(layer_meta.clone());
+
+    // Create new WAL file for the new materialized graph.
+    let ext = Extension::new(config, path)?;
+
+    let temporal_graph = TemporalGraph::new_with_meta(
+        path.map(|p| p.into()),
+        node_meta,
+        edge_meta,
+        graph_props_meta,
+        ext,
+    )?;
+
+    if let Some(earliest) = graph.earliest_time() {
+        temporal_graph.update_time(earliest);
+    };
+
+    if let Some(latest) = graph.latest_time() {
+        temporal_graph.update_time(latest);
+    };
+
+    // Set event counter to be the same as old graph to avoid any possibility for duplicate event ids
+    temporal_graph
+        .storage()
+        .set_event_id(storage.read_event_id());
+
+    let temporal_graph = Arc::new(temporal_graph);
+    let graph_storage = GraphStorage::from(temporal_graph.clone());
+
+    {
+        // scope for the write lock
+
+        // reverse index pos -> new_vid
+        let index = Index::for_graph(graph);
+        let mut node_map = vec![VID::default(); index.len()];
+        let node_map_shared = atomic_usize_from_mut_slice(bytemuck::cast_slice_mut(&mut node_map));
+
+        index.par_iter().for_each(|(_, vid)| {
+            if let Some(pos) = index.index(&vid) {
+                let new_vid = temporal_graph.storage().nodes().reserve_vid(pos);
+                node_map_shared[pos].store(new_vid.index(), Ordering::Relaxed);
             }
-        };
+        });
 
-        if let Some(earliest) = self.earliest_time() {
-            g.update_time(earliest);
-        } else {
-            return Ok(self.new_base_graph(g.into()));
+        let get_new_vid = |old_vid: VID, index: &Index<VID>, node_map: &[VID]| -> VID {
+            let pos = index
+                .index(&old_vid)
+                .expect("old_vid should exist in index");
+            node_map[pos]
         };
+        let mut new_storage = graph_storage.write_lock()?;
 
-        if let Some(latest) = self.latest_time() {
-            g.update_time(latest);
-        } else {
-            return Ok(self.new_base_graph(g.into()));
-        };
+        for layer_id in &layer_map {
+            new_storage.nodes.ensure_layer(LayerId(*layer_id));
+        }
 
-        // Set event counter to be the same as old graph to avoid any possibility for duplicate event ids
-        g.event_counter
-            .fetch_max(storage.read_event_id(), Ordering::Relaxed);
+        new_storage.nodes.par_iter_mut().try_for_each(|shard| {
+            for (pos, vid) in index.iter().enumerate() {
+                let new_id = node_map[pos];
+                if let Some(node_pos) = shard.resolve_pos(new_id) {
+                    let node = NodeView::new_internal(graph, vid);
+                    let gid = node.id();
+                    let mut writer = shard.writer();
+
+                    if let Some(node_type) = node.node_type() {
+                        let new_type_id = graph_storage
+                            .node_meta()
+                            .node_type_meta()
+                            .get_or_create_id(&node_type)
+                            .inner();
+                        writer.store_node_id_and_node_type(
+                            node_pos,
+                            STATIC_GRAPH_LAYER_ID,
+                            gid.as_ref(),
+                            new_type_id,
+                        );
+                    } else {
+                        writer.store_node_id(node_pos, STATIC_GRAPH_LAYER_ID, gid.clone());
+                    }
 
-        let g = GraphStorage::from(g);
+                    graph_storage
+                        .write_session()?
+                        .set_node(gid.as_ref(), new_id)?;
 
-        {
-            // scope for the write lock
-            let mut new_storage = g.write_lock()?;
-            new_storage.nodes.resize(self.count_nodes());
+                    for (t, l, row) in node.rows() {
+                        writer.add_props(t, node_pos, LayerId(l.0), row); // TODO: Fix me
+                    }
 
-            let mut node_map = vec![VID::default(); storage.unfiltered_num_nodes()];
-            let node_map_shared =
-                atomic_usize_from_mut_slice(bytemuck::cast_slice_mut(&mut node_map));
+                    writer.update_c_props(
+                        node_pos,
+                        STATIC_GRAPH_LAYER_ID,
+                        node.metadata_ids()
+                            .filter_map(|id| node.get_metadata(id).map(|prop| (id, prop))),
+                    );
+                }
+            }
 
-            new_storage.nodes.par_iter_mut().try_for_each(|mut shard| {
-                for (index, node) in self.nodes().iter().enumerate() {
-                    let new_id = VID(index);
-                    let gid = node.id();
-                    if let Some(mut new_node) = shard.set(new_id, gid.as_ref()) {
-                        node_map_shared[node.node.index()].store(index, Ordering::Relaxed);
-                        if let Some(node_type) = node.node_type() {
-                            let new_type_id = g
-                                .node_meta()
-                                .node_type_meta()
-                                .get_or_create_id(&node_type)
-                                .inner();
-                            new_node.node_store_mut().node_type = new_type_id;
-                        }
-                        g.set_node(gid.as_ref(), new_id)?;
+            Ok::<(), MutationError>(())
+        })?;
 
-                        for (t, rows) in node.rows() {
-                            let prop_offset = new_node.t_props_log_mut().push(rows)?;
-                            new_node.node_store_mut().update_t_prop_time(t, prop_offset);
-                        }
+        let mut new_eids = vec![];
+        let mut max_eid = 0usize;
+        for (row, _) in graph.edges().iter().enumerate() {
+            let new_eid = new_storage.graph().storage().edges().reserve_new_eid(row);
+            new_eids.push(new_eid);
+            max_eid = new_eid.0.max(max_eid);
+        }
+        new_storage.resize_segments_to_eid(EID(max_eid));
 
-                        for metadata_id in node.metadata_ids() {
-                            if let Some(prop_value) = node.get_metadata(metadata_id) {
-                                new_node
-                                    .node_store_mut()
-                                    .add_metadata(metadata_id, prop_value)?;
-                            }
+        for layer_id in &layer_map {
+            new_storage.edges.ensure_layer(LayerId(*layer_id));
+        }
+
+        new_storage.edges.par_iter_mut().try_for_each(|shard| {
+            for (row, edge) in graph.edges().iter().enumerate() {
+                let src = get_new_vid(edge.edge.src(), &index, &node_map);
+                let dst = get_new_vid(edge.edge.dst(), &index, &node_map);
+                let eid = new_eids[row];
+                if let Some(edge_pos) = shard.resolve_pos(eid) {
+                    let mut writer = shard.writer();
+                    // make the edge for the first time
+                    writer.add_static_edge(Some(edge_pos), src, dst, false);
+
+                    for edge in edge.explode_layers() {
+                        let layer = LayerId(layer_map[edge.edge.layer().unwrap().0]);
+                        for edge in edge.explode() {
+                            let t = edge.edge.time().unwrap();
+                            writer.add_edge(t, edge_pos, src, dst, [], layer);
+                        }
+                        //TODO: move this in edge.row()
+                        for (t, t_props) in edge
+                            .properties()
+                            .temporal()
+                            .values()
+                            .map(|tp| {
+                                let prop_id = tp.id();
+                                tp.iter_indexed()
+                                    .map(|(t, prop)| (t, prop_id, prop))
+                                    .collect::<Vec<_>>()
+                            })
+                            .kmerge_by(|(t, _, _), (t2, _, _)| t <= t2)
+                            .chunk_by(|(t, _, _)| *t)
+                            .into_iter()
+                        {
+                            let props = t_props
+                                .map(|(_, prop_id, prop)| (prop_id, prop))
+                                .collect::<Vec<_>>();
+                            writer.add_edge(t, edge_pos, src, dst, props, layer);
                         }
+                        writer.update_c_props(
+                            edge_pos,
+                            src,
+                            dst,
+                            layer,
+                            edge.clone().metadata_ids().filter_map(move |prop_id| {
+                                edge.get_metadata(prop_id).map(|prop| (prop_id, prop))
+                            }),
+                        );
+                    }
+
+                    let time_semantics = graph.edge_time_semantics();
+                    let edge_entry = graph.core_edge(edge.edge.pid());
+                    for (t, layer) in time_semantics.edge_deletion_history(
+                        edge_entry.as_ref(),
+                        graph,
+                        graph.layer_ids(),
+                    ) {
+                        let layer = LayerId(layer_map[layer.0]);
+                        writer.delete_edge(t, edge_pos, src, dst, layer);
                     }
                 }
-                Ok::<(), MutationError>(())
-            })?;
-
-            new_storage.edges.par_iter_mut().try_for_each(|mut shard| {
-                for (eid, edge) in self.edges().iter().enumerate() {
-                    if let Some(mut new_edge) = shard.get_mut(EID(eid)) {
-                        let edge_store = new_edge.edge_store_mut();
-                        edge_store.src = node_map[edge.edge.src().index()];
-                        edge_store.dst = node_map[edge.edge.dst().index()];
-                        edge_store.eid = EID(eid);
-                        for edge in edge.explode_layers() {
-                            let layer = layer_map[edge.edge.layer().unwrap()];
-                            let additions = new_edge.additions_mut(layer);
-                            for edge in edge.explode() {
-                                let t = edge.edge.time().unwrap();
-                                additions.insert(t);
-                            }
-                            for t_prop in edge.properties().temporal().values() {
-                                let prop_id = t_prop.id();
-                                for (t, prop_value) in t_prop.iter_indexed() {
-                                    new_edge.layer_mut(layer).add_prop(t, prop_id, prop_value)?;
-                                }
-                            }
-                            for c_prop in edge.metadata_ids() {
-                                if let Some(prop_value) = edge.get_metadata(c_prop) {
-                                    new_edge.layer_mut(layer).add_metadata(c_prop, prop_value)?;
-                                }
-                            }
-                        }
+            }
+            Ok::<(), MutationError>(())
+        })?;
+
+        new_storage.nodes.par_iter_mut().try_for_each(|shard| {
+            for (row, edge) in graph.edges().iter().enumerate() {
+                let eid = new_eids[row];
+                let src_id = get_new_vid(edge.edge.src(), &index, &node_map);
+                let dst_id = get_new_vid(edge.edge.dst(), &index, &node_map);
+                let maybe_src_pos = shard.resolve_pos(src_id);
+                let maybe_dst_pos = shard.resolve_pos(dst_id);
+
+                if let Some(node_pos) = maybe_src_pos {
+                    let mut writer = shard.writer();
+                    writer.add_static_outbound_edge(node_pos, dst_id, eid);
+                }
 
-                        let time_semantics = self.edge_time_semantics();
-                        let edge_entry = self.core_edge(edge.edge.pid());
-                        for (t, layer) in time_semantics.edge_deletion_history(
-                            edge_entry.as_ref(),
-                            self,
-                            self.layer_ids(),
-                        ) {
-                            new_edge.deletions_mut(layer_map[layer]).insert(t);
-                        }
+                if let Some(node_pos) = maybe_dst_pos {
+                    let mut writer = shard.writer();
+                    writer.add_static_inbound_edge(node_pos, src_id, eid);
+                }
+
+                for e in edge.explode_layers() {
+                    let layer = LayerId(layer_map[e.edge.layer().unwrap().0]);
+                    if let Some(node_pos) = maybe_src_pos {
+                        let mut writer = shard.writer();
+                        writer.add_outbound_edge::<i64>(
+                            None,
+                            node_pos,
+                            dst_id,
+                            eid.with_layer(layer),
+                        );
+                    }
+                    if let Some(node_pos) = maybe_dst_pos {
+                        let mut writer = shard.writer();
+                        writer.add_inbound_edge::<i64>(
+                            None,
+                            node_pos,
+                            src_id,
+                            eid.with_layer(layer),
+                        );
                     }
                 }
-                Ok::<(), MutationError>(())
-            })?;
-
-            new_storage.nodes.par_iter_mut().try_for_each(|mut shard| {
-                for (eid, edge) in self.edges().iter().enumerate() {
-                    if let Some(src_node) = shard.get_mut(node_map[edge.edge.src().index()]) {
-                        for e in edge.explode() {
-                            let t = e
-                                .time_and_event_id()
-                                .expect("exploded edge should have time");
-                            let l = layer_map[e.edge.layer().unwrap()];
-                            src_node.update_time(t, EID(eid).with_layer(l));
-                        }
-                        for ee in edge.explode_layers() {
-                            src_node.add_edge(
-                                node_map[edge.edge.dst().index()],
-                                Direction::OUT,
-                                layer_map[ee.edge.layer().unwrap()],
-                                EID(eid),
-                            );
-                        }
+
+                for e in edge.explode() {
+                    if let Some(src_pos) = maybe_src_pos {
+                        let mut writer = shard.writer();
+
+                        let t = e.time().expect("exploded edge should have time");
+                        let l = LayerId(layer_map[e.edge.layer().unwrap().0]);
+                        writer.update_timestamp(t, src_pos, eid.with_layer(l));
                     }
-                    if let Some(dst_node) = shard.get_mut(node_map[edge.edge.dst().index()]) {
-                        for e in edge.explode() {
-                            let t = e
-                                .time_and_event_id()
-                                .expect("exploded edge should have time");
-                            let l = layer_map[e.edge.layer().unwrap()];
-                            dst_node.update_time(t, EID(eid).with_layer(l));
-                        }
-                        for ee in edge.explode_layers() {
-                            dst_node.add_edge(
-                                node_map[edge.edge.src().index()],
-                                Direction::IN,
-                                layer_map[ee.edge.layer().unwrap()],
-                                EID(eid),
-                            );
+                    if let Some(dst_pos) = maybe_dst_pos {
+                        if maybe_src_pos.is_none_or(|src_pos| src_pos != dst_pos) {
+                            let mut writer = shard.writer();
+
+                            let t = e.time().expect("exploded edge should have time");
+                            let l = LayerId(layer_map[e.edge.layer().unwrap().0]);
+                            writer.update_timestamp(t, dst_pos, eid.with_layer(l));
                         }
                     }
+                }
 
-                    let edge_time_semantics = self.edge_time_semantics();
-                    let edge_entry = self.core_edge(edge.edge.pid());
-                    for (t, layer) in edge_time_semantics.edge_deletion_history(
-                        edge_entry.as_ref(),
-                        self,
-                        self.layer_ids(),
-                    ) {
-                        if let Some(src_node) = shard.get_mut(node_map[edge.edge.src().index()]) {
-                            src_node.update_time(t, EID(eid).with_layer_deletion(layer_map[layer]));
-                        }
-                        if let Some(dst_node) = shard.get_mut(node_map[edge.edge.dst().index()]) {
-                            dst_node.update_time(t, EID(eid).with_layer_deletion(layer_map[layer]));
+                let edge_time_semantics = graph.edge_time_semantics();
+                let edge_entry = graph.core_edge(edge.edge.pid());
+                for (t, layer) in edge_time_semantics.edge_deletion_history(
+                    edge_entry.as_ref(),
+                    graph,
+                    graph.layer_ids(),
+                ) {
+                    let layer = LayerId(layer_map[layer.0]);
+                    if let Some(src_pos) = maybe_src_pos {
+                        let mut writer = shard.writer();
+                        writer.update_timestamp(t, src_pos, eid.with_layer_deletion(layer));
+                    }
+                    if let Some(dst_pos) = maybe_dst_pos {
+                        if maybe_src_pos.is_none_or(|src_pos| src_pos != dst_pos) {
+                            let mut writer = shard.writer();
+                            writer.update_timestamp(t, dst_pos, eid.with_layer_deletion(layer));
                         }
                     }
                 }
+            }
+
+            Ok::<(), MutationError>(())
+        })?;
+
+        // Copy over graph properties
+        {
+            let graph_writer = new_storage.graph_props.writer();
+            // Copy temporal properties
+            for (prop_name, temporal_prop) in graph.properties().temporal().iter() {
+                let prop_id = graph_storage
+                    .graph_props_meta()
+                    .temporal_prop_mapper()
+                    .get_or_create_id(&prop_name)
+                    .inner();
+
+                for (t, prop_value) in temporal_prop.iter_indexed() {
+                    graph_writer.add_properties(t, [(prop_id, prop_value)]);
+                }
+            }
 
-                Ok::<(), MutationError>(())
-            })?;
+            // Copy metadata (constant properties)
+            let metadata_props: Vec<_> = graph
+                .metadata()
+                .iter_filtered()
+                .map(|(prop_name, prop_value)| {
+                    let prop_id = graph_storage
+                        .graph_props_meta()
+                        .metadata_mapper()
+                        .get_or_create_id(&prop_name)
+                        .inner();
+                    (prop_id, prop_value)
+                })
+                .collect();
+
+            if !metadata_props.is_empty() {
+                graph_writer.update_metadata(metadata_props);
+            }
         }
+    }
 
-        Ok(self.new_base_graph(g))
+    Ok(graph.new_base_graph(graph_storage))
+}
+
+impl<'graph, G: GraphView + 'graph> GraphViewOps<'graph> for G {
+    fn edges(&self) -> Edges<'graph, Self> {
+        edges_inner(self, true)
+    }
+
+    fn edges_unlocked(&self) -> Edges<'graph, Self> {
+        edges_inner(self, false)
+    }
+
+    fn nodes(&self) -> Nodes<'graph, Self> {
+        let graph = self.clone();
+        Nodes::new(graph)
+    }
+
+    fn materialize(&self) -> Result<MaterializedGraph, GraphError> {
+        materialize_impl(self, None, self.core_graph().extension().config().clone())
+    }
+
+    #[cfg(feature = "io")]
+    fn materialize_at_with_config(
+        &self,
+        path: &(impl GraphPaths + ?Sized),
+        config: Config,
+    ) -> Result<MaterializedGraph, GraphError> {
+        if Extension::disk_storage_enabled() {
+            path.init()?;
+            let graph_path = path.graph_path()?;
+            let graph = materialize_impl(self, Some(graph_path.as_ref()), config)?;
+            path.write_metadata(&graph)?;
+            Ok(graph)
+        } else {
+            Err(GraphError::DiskGraphNotEnabled)
+        }
     }
 
     fn subgraph<I: IntoIterator<Item = V>, V: AsNodeRef>(&self, nodes: I) -> NodeSubgraph<G> {
@@ -479,10 +682,10 @@ impl<'graph, G: GraphView + 'graph> GraphViewOps<'graph> for G {
     /// Get the `EventTime` of the earliest activity in the graph.
     #[inline]
     fn earliest_time(&self) -> Option<EventTime> {
-        match self.filter_state() {
-            FilterState::Neither => self.earliest_time_global().map(EventTime::start), // TODO: change earliest_time_global() to return EventTime
-            _ => self
-                .properties()
+        if self.layer_ids().is_all() && !self.filtered() {
+            self.earliest_time_global().map(EventTime::start)
+        } else {
+            self.properties()
                 .temporal()
                 .values()
                 .flat_map(|prop| prop.history().earliest_time())
@@ -495,24 +698,24 @@ impl<'graph, G: GraphView + 'graph> GraphViewOps<'graph> for G {
                         .flatten()
                         .min(),
                 )
-                .min(),
+                .min()
         }
     }
 
     /// Get the `EventTime` of the latest activity in the graph.
     #[inline]
     fn latest_time(&self) -> Option<EventTime> {
-        match self.filter_state() {
-            FilterState::Neither => self.latest_time_global().map(EventTime::end), // TODO: change latest_time_global to return EventTime
-            _ => self
-                .properties()
+        if self.layer_ids().is_all() && !self.filtered() {
+            self.latest_time_global().map(EventTime::end)
+        } else {
+            self.properties()
                 .temporal()
                 .values()
                 .flat_map(|prop| prop.history().latest_time())
                 .max()
                 .into_iter()
                 .chain(self.nodes().latest_time().par_iter_values().flatten().max())
-                .max(),
+                .max()
         }
     }
 
@@ -531,7 +734,7 @@ impl<'graph, G: GraphView + 'graph> GraphViewOps<'graph> for G {
                 .filter(|e| self.filter_edge(e.as_ref()))
                 .count()
         } else {
-            self.unfiltered_num_edges()
+            self.unfiltered_num_edges(self.layer_ids())
         }
     }
 
@@ -632,7 +835,7 @@ pub struct IndexSpec {
 
 /// (Experimental) IndexSpec data structure.
 impl IndexSpec {
-    pub(crate) fn diff(existing: &IndexSpec, requested: &IndexSpec) -> Option<IndexSpec> {
+    pub fn diff(existing: &IndexSpec, requested: &IndexSpec) -> Option<IndexSpec> {
         fn diff_props(existing: &HashSet<usize>, requested: &HashSet<usize>) -> HashSet<usize> {
             requested.difference(existing).copied().collect()
         }
@@ -658,7 +861,7 @@ impl IndexSpec {
         }
     }
 
-    pub(crate) fn union(existing: &IndexSpec, other: &IndexSpec) -> IndexSpec {
+    pub fn union(existing: &IndexSpec, other: &IndexSpec) -> IndexSpec {
         fn union_props(a: &HashSet<usize>, b: &HashSet<usize>) -> HashSet<usize> {
             a.union(b).copied().collect()
         }
@@ -885,7 +1088,7 @@ impl<G: BoxableGraphView + Sized + Clone + 'static> IndexSpecBuilder<G> {
 
     /// Extract properties or metadata.
     fn extract_props(meta: &PropMapper) -> HashSet<usize> {
-        (0..meta.len()).collect()
+        meta.ids().collect()
     }
 
     /// Extract specified named properties or metadata.
diff --git a/raphtory/src/db/api/view/history.rs b/raphtory/src/db/api/view/history.rs
index 84de17c46e..50fdb80002 100644
--- a/raphtory/src/db/api/view/history.rs
+++ b/raphtory/src/db/api/view/history.rs
@@ -104,7 +104,7 @@ impl<'a, T: InternalHistoryOps + 'a> History<'a, T> {
         History::new(MergedHistory::new(self.0, right.0))
     }
 
-    fn into_iter_rev(self) -> BoxedLIter<'a, EventTime> {
+    pub fn into_iter_rev(self) -> BoxedLIter<'a, EventTime> {
         GenLockedIter::from(self.0, |item| item.iter_rev()).into_dyn_boxed()
     }
 
@@ -486,7 +486,7 @@ impl<'graph, G: GraphViewOps<'graph> + Send + Sync + Send + Sync> InternalHistor
         let node = self.graph.core_node(self.node);
         GenLockedIter::from(node, move |node| {
             semantics
-                .node_history(node.as_ref(), &self.graph)
+                .node_history(node.as_ref(), &self.graph, self.graph.layer_ids())
                 .into_dyn_boxed()
         })
         .into_dyn_boxed()
@@ -497,7 +497,7 @@ impl<'graph, G: GraphViewOps<'graph> + Send + Sync + Send + Sync> InternalHistor
         let node = self.graph.core_node(self.node);
         GenLockedIter::from(node, move |node| {
             semantics
-                .node_history_rev(node.as_ref(), &self.graph)
+                .node_history_rev(node.as_ref(), &self.graph, self.graph.layer_ids())
                 .into_dyn_boxed()
         })
         .into_dyn_boxed()
@@ -722,7 +722,7 @@ impl<G: GraphViewOps<'static>> IntoArcDynHistoryOps for PathFromNode<'static, G>
 
 impl<'graph, G: GraphViewOps<'graph>> InternalHistoryOps for PathFromGraph<'graph, G> {
     fn iter(&self) -> BoxedLIter<'_, EventTime> {
-        self.iter()
+        self.iter_values()
             .map(|path_from_node| {
                 GenLockedIter::from(path_from_node, |item| InternalHistoryOps::iter(item))
             })
@@ -731,7 +731,7 @@ impl<'graph, G: GraphViewOps<'graph>> InternalHistoryOps for PathFromGraph<'grap
     }
 
     fn iter_rev(&self) -> BoxedLIter<'_, EventTime> {
-        self.iter()
+        self.iter_values()
             .map(|path_from_node| {
                 GenLockedIter::from(path_from_node, |item| InternalHistoryOps::iter_rev(item))
             })
@@ -740,13 +740,13 @@ impl<'graph, G: GraphViewOps<'graph>> InternalHistoryOps for PathFromGraph<'grap
     }
 
     fn earliest_time(&self) -> Option<EventTime> {
-        self.iter()
+        self.iter_values()
             .filter_map(|path_from_node| InternalHistoryOps::earliest_time(&path_from_node))
             .min()
     }
 
     fn latest_time(&self) -> Option<EventTime> {
-        self.iter()
+        self.iter_values()
             .filter_map(|path_from_node| InternalHistoryOps::latest_time(&path_from_node))
             .max()
     }
diff --git a/raphtory/src/db/api/view/internal/edge_filter_ops.rs b/raphtory/src/db/api/view/internal/edge_filter_ops.rs
index 6014dd7336..7f872e8bed 100644
--- a/raphtory/src/db/api/view/internal/edge_filter_ops.rs
+++ b/raphtory/src/db/api/view/internal/edge_filter_ops.rs
@@ -1,9 +1,12 @@
 use crate::core::entities::LayerIds;
 use raphtory_api::{
-    core::{entities::ELID, storage::timeindex::EventTime},
+    core::{
+        entities::{LayerId, ELID},
+        storage::timeindex::EventTime,
+    },
     inherit::Base,
 };
-use raphtory_storage::graph::edges::edge_ref::EdgeStorageRef;
+use storage::EdgeEntryRef;
 
 pub trait InternalEdgeLayerFilterOps {
     /// Set to true when filtering, used for optimisations
@@ -13,7 +16,7 @@ pub trait InternalEdgeLayerFilterOps {
     fn internal_layer_filter_edge_list_trusted(&self) -> bool;
 
     /// Filter a layer for an edge
-    fn internal_filter_edge_layer(&self, edge: EdgeStorageRef, layer: usize) -> bool;
+    fn internal_filter_edge_layer(&self, edge: EdgeEntryRef, layer: LayerId) -> bool;
 
     fn node_filter_includes_edge_layer_filter(&self) -> bool {
         false
@@ -57,7 +60,7 @@ pub trait InternalEdgeFilterOps {
     /// If true, all edges returned by `self.edge_list()` exist, otherwise it needs further filtering
     fn internal_edge_list_trusted(&self) -> bool;
 
-    fn internal_filter_edge(&self, edge: EdgeStorageRef, layer_ids: &LayerIds) -> bool;
+    fn internal_filter_edge(&self, edge: EdgeEntryRef, layer_ids: &LayerIds) -> bool;
 
     fn node_filter_includes_edge_filter(&self) -> bool {
         false
@@ -89,7 +92,7 @@ impl<G: InheritEdgeFilterOps<Base: InternalEdgeFilterOps>> InternalEdgeFilterOps
         self.base().internal_edge_list_trusted()
     }
     #[inline]
-    fn internal_filter_edge(&self, edge: EdgeStorageRef, layer_ids: &LayerIds) -> bool {
+    fn internal_filter_edge(&self, edge: EdgeEntryRef, layer_ids: &LayerIds) -> bool {
         self.base().internal_filter_edge(edge, layer_ids)
     }
 
@@ -117,7 +120,7 @@ impl<G: InheritEdgeLayerFilterOps<Base: InternalEdgeLayerFilterOps>> InternalEdg
     }
 
     #[inline]
-    fn internal_filter_edge_layer(&self, edge: EdgeStorageRef, layer: usize) -> bool {
+    fn internal_filter_edge_layer(&self, edge: EdgeEntryRef, layer: LayerId) -> bool {
         self.base().internal_filter_edge_layer(edge, layer)
     }
 
diff --git a/raphtory/src/db/api/view/internal/filter_ops.rs b/raphtory/src/db/api/view/internal/filter_ops.rs
index c74ac1ffe2..3a7be546a5 100644
--- a/raphtory/src/db/api/view/internal/filter_ops.rs
+++ b/raphtory/src/db/api/view/internal/filter_ops.rs
@@ -4,14 +4,15 @@ use iter_enum::{
     ParallelIterator,
 };
 use raphtory_api::core::{
-    entities::ELID,
+    entities::{LayerId, LayerIds, ELID},
     storage::timeindex::{EventTime, TimeIndexOps},
 };
 use raphtory_storage::graph::{
-    edges::{edge_ref::EdgeStorageRef, edge_storage_ops::EdgeStorageOps},
-    nodes::node_ref::NodeStorageRef,
+    edges::{edge_ref::EdgeEntryRef, edge_storage_ops::EdgeStorageOps},
+    nodes::{node_ref::NodeStorageRef, node_storage_ops::NodeStorageOps},
 };
 
+#[derive(Debug)]
 pub enum FilterState {
     Neither,
     Both,
@@ -44,16 +45,16 @@ pub trait FilterOps {
 
     fn node_list_trusted(&self) -> bool;
 
-    fn filter_edge(&self, edge: EdgeStorageRef) -> bool;
+    fn filter_edge(&self, edge: EdgeEntryRef) -> bool;
 
-    fn filter_edge_layer(&self, edge: EdgeStorageRef, layer: usize) -> bool;
+    fn filter_edge_layer(&self, edge: EdgeEntryRef, layer: LayerId) -> bool;
 
     fn filter_exploded_edge(&self, eid: ELID, t: EventTime) -> bool;
 
     fn edge_list_trusted(&self) -> bool;
 
     fn exploded_filter_independent(&self) -> bool;
-    fn filter_edge_from_nodes(&self, edge: EdgeStorageRef) -> bool;
+    fn filter_edge_from_nodes(&self, edge: EdgeEntryRef) -> bool;
 }
 
 /// Implements all the filtering except for time semantics as it is used to define the time semantics
@@ -62,12 +63,14 @@ pub trait InnerFilterOps {
 
     fn filtered_inner(&self) -> bool;
 
-    fn filter_edge_inner(&self, edge: EdgeStorageRef) -> bool;
+    fn filter_edge_inner(&self, edge: EdgeEntryRef) -> bool;
 
     /// handles edge and edge layer filter (not exploded edge filter or windows)
-    fn filter_edge_layer_inner(&self, edge: EdgeStorageRef, layer: usize) -> bool;
+    fn filter_edge_layer_inner(&self, edge: EdgeEntryRef, layer: LayerId) -> bool;
 
     fn filter_exploded_edge_inner(&self, eid: ELID, t: EventTime) -> bool;
+
+    fn is_layer_filtered(&self) -> bool;
 }
 
 impl<G: GraphView> InnerFilterOps for G {
@@ -82,7 +85,7 @@ impl<G: GraphView> InnerFilterOps for G {
             || self.internal_exploded_edge_filtered()
     }
 
-    fn filter_edge_inner(&self, edge: EdgeStorageRef) -> bool {
+    fn filter_edge_inner(&self, edge: EdgeEntryRef) -> bool {
         self.internal_filter_edge(edge, self.layer_ids())
             && (self.edge_filter_includes_edge_layer_filter()
                 || edge
@@ -92,7 +95,7 @@ impl<G: GraphView> InnerFilterOps for G {
             && self.filter_edge_from_nodes(edge)
     }
 
-    fn filter_edge_layer_inner(&self, edge: EdgeStorageRef, layer: usize) -> bool {
+    fn filter_edge_layer_inner(&self, edge: EdgeEntryRef, layer: LayerId) -> bool {
         self.layer_ids().contains(&layer)
             && self.internal_filter_edge_layer(edge, layer)
             && (self.edge_layer_filter_includes_edge_filter()
@@ -113,6 +116,10 @@ impl<G: GraphView> InnerFilterOps for G {
                     && self.filter_edge_from_nodes(edge.as_ref())
             })
     }
+
+    fn is_layer_filtered(&self) -> bool {
+        !matches!(self.layer_ids(), LayerIds::All)
+    }
 }
 
 impl<G: GraphView> FilterOps for G {
@@ -123,7 +130,11 @@ impl<G: GraphView> FilterOps for G {
             self.internal_filter_node(node, self.layer_ids())
                 && time_semantics.node_valid(node, self)
         } else {
-            true
+            if self.is_layer_filtered() {
+                node.has_layers(self.layer_ids())
+            } else {
+                true
+            }
         }
     }
 
@@ -173,7 +184,7 @@ impl<G: GraphView> FilterOps for G {
             && self.node_filter_includes_exploded_edge_filter()
     }
 
-    fn filter_edge(&self, edge: EdgeStorageRef) -> bool {
+    fn filter_edge(&self, edge: EdgeEntryRef) -> bool {
         self.internal_filter_edge(edge, self.layer_ids()) && self.filter_edge_from_nodes(edge) && {
             let time_semantics = self.edge_time_semantics();
             edge.layer_ids_iter(self.layer_ids()).any(|layer_id| {
@@ -183,7 +194,7 @@ impl<G: GraphView> FilterOps for G {
         }
     }
 
-    fn filter_edge_layer(&self, edge: EdgeStorageRef, layer: usize) -> bool {
+    fn filter_edge_layer(&self, edge: EdgeEntryRef, layer: LayerId) -> bool {
         self.internal_filter_edge_layer(edge, layer)
             && (self.edge_layer_filter_includes_edge_filter()
                 || self.internal_filter_edge(edge, self.layer_ids()))
@@ -206,7 +217,7 @@ impl<G: GraphView> FilterOps for G {
             && self.exploded_edge_filter_includes_edge_layer_filter()
     }
 
-    fn filter_edge_from_nodes(&self, edge: EdgeStorageRef) -> bool {
+    fn filter_edge_from_nodes(&self, edge: EdgeEntryRef) -> bool {
         self.exploded_edge_filter_includes_node_filter()
             || self.edge_layer_filter_includes_node_filter()
             || self.edge_filter_includes_node_filter()
@@ -215,7 +226,7 @@ impl<G: GraphView> FilterOps for G {
     }
 }
 
-fn filter_edge_from_exploded_filter<G: GraphView>(view: &G, edge: EdgeStorageRef) -> bool {
+fn filter_edge_from_exploded_filter<G: GraphView>(view: &G, edge: EdgeEntryRef) -> bool {
     view.edge_filter_includes_exploded_edge_filter()
         || view.edge_layer_filter_includes_exploded_edge_filter()
         || {
diff --git a/raphtory/src/db/api/view/internal/list_ops.rs b/raphtory/src/db/api/view/internal/list_ops.rs
index 7f56c5852d..8fd76a3810 100644
--- a/raphtory/src/db/api/view/internal/list_ops.rs
+++ b/raphtory/src/db/api/view/internal/list_ops.rs
@@ -2,8 +2,9 @@ use crate::{
     core::entities::{EID, VID},
     db::api::{state::Index, view::Base},
 };
+use raphtory_storage::graph::graph::GraphStorage;
 use rayon::{iter::Either, prelude::*};
-use std::hash::Hash;
+use std::{hash::Hash, sync::Arc};
 
 pub trait ListOps {
     fn node_list(&self) -> NodeList;
@@ -28,7 +29,7 @@ where
 
 #[derive(Debug)]
 pub enum List<I> {
-    All { len: usize },
+    All,
     List { elems: Index<I> },
 }
 
@@ -38,7 +39,7 @@ pub type EdgeList = List<EID>;
 impl<I> Clone for List<I> {
     fn clone(&self) -> Self {
         match self {
-            List::All { len } => List::All { len: *len },
+            List::All => List::All,
             List::List { elems } => List::List {
                 elems: elems.clone(),
             },
@@ -49,10 +50,7 @@ impl<I> Clone for List<I> {
 impl<I: Copy + Eq + Hash + Into<usize> + From<usize> + Send + Sync> List<I> {
     pub fn intersection(&self, other: &List<I>) -> List<I> {
         match (self, other) {
-            (List::All { len: a }, List::All { len: b }) => {
-                let len = *a.min(b);
-                List::All { len }
-            }
+            (List::All, List::All) => List::All,
             (List::List { .. }, List::All { .. }) => self.clone(),
             (List::All { .. }, List::List { .. }) => other.clone(),
             (List::List { elems: a }, List::List { elems: b }) => {
@@ -62,45 +60,54 @@ impl<I: Copy + Eq + Hash + Into<usize> + From<usize> + Send + Sync> List<I> {
         }
     }
 
-    pub fn par_iter(&self) -> impl IndexedParallelIterator<Item = I> + '_ {
+    pub fn union(&self, other: &List<I>) -> List<I> {
         match self {
-            List::All { len } => Either::Left((0..*len).into_par_iter().map(From::from)),
-            List::List { elems } => Either::Right(elems.par_iter()),
+            List::All => List::All,
+            List::List { elems: left } => match other {
+                List::All => List::All,
+                List::List { elems: right } => List::List {
+                    elems: left.union(right),
+                },
+            },
         }
     }
 
-    pub fn into_par_iter(self) -> impl IndexedParallelIterator<Item = I> {
-        match self {
-            List::All { len } => Either::Left((0..len).into_par_iter().map(From::from)),
-            List::List { elems } => Either::Right(elems.into_par_iter()),
+    pub fn unfiltered(&self) -> bool {
+        matches!(self, List::All)
+    }
+
+    pub fn empty() -> Self {
+        List::List {
+            elems: Index::default(),
         }
     }
+}
 
-    pub fn iter(&self) -> impl Iterator<Item = I> + '_ {
+impl List<VID> {
+    pub fn nodes_iter(self, g: &GraphStorage) -> impl Iterator<Item = VID> {
         match self {
-            List::All { len } => Either::Left((0..*len).map(From::from)),
-            List::List { elems } => Either::Right(elems.iter()),
+            List::All => {
+                let sc = g.node_segment_counts();
+                Either::Left(sc.into_iter())
+            }
+            List::List { elems } => Either::Right(elems.into_iter()),
         }
     }
 
-    pub fn len(&self) -> usize {
+    pub fn into_index(self, g: &GraphStorage) -> Index<VID> {
         match self {
-            List::All { len } => *len,
-            List::List { elems } => elems.len(),
+            List::All => Index::Full(Arc::new(g.node_state_index())),
+            List::List { elems } => elems,
         }
     }
-}
-
-impl<I: Copy + Eq + Hash + Into<usize> + From<usize> + Send + Sync + 'static> IntoIterator
-    for List<I>
-{
-    type Item = I;
-    type IntoIter = Box<dyn Iterator<Item = Self::Item> + Send + Sync>;
 
-    fn into_iter(self) -> Self::IntoIter {
+    pub fn nodes_par_iter(self, g: &GraphStorage) -> impl ParallelIterator<Item = VID> {
         match self {
-            List::All { len } => Box::new((0..len).map(From::from)),
-            List::List { elems } => Box::new(elems.into_iter()),
+            List::All => {
+                let sc = g.node_segment_counts();
+                Either::Left(sc.into_par_iter())
+            }
+            List::List { elems } => Either::Right(elems.into_par_iter()),
         }
     }
 }
diff --git a/raphtory/src/db/api/view/internal/materialize.rs b/raphtory/src/db/api/view/internal/materialize.rs
index b7fbe41be8..09b438a17b 100644
--- a/raphtory/src/db/api/view/internal/materialize.rs
+++ b/raphtory/src/db/api/view/internal/materialize.rs
@@ -1,17 +1,20 @@
+#[cfg(feature = "io")]
+use crate::serialise::GraphPaths;
 use crate::{
     core::storage::timeindex::EventTime,
     db::{
         api::view::internal::*,
         graph::{graph::Graph, views::deletion_graph::PersistentGraph},
     },
+    errors::GraphError,
     prelude::*,
 };
-use raphtory_api::{iter::BoxedLDIter, GraphType};
+use raphtory_api::{iter::BoxedLIter, GraphType};
 use raphtory_storage::{graph::graph::GraphStorage, mutation::InheritMutationOps};
-use serde::{Deserialize, Serialize};
 use std::ops::Range;
+use storage::Config;
 
-#[derive(Serialize, Deserialize, Clone)]
+#[derive(Clone)]
 pub enum MaterializedGraph {
     EventGraph(Graph),
     PersistentGraph(PersistentGraph),
@@ -91,12 +94,51 @@ impl MaterializedGraph {
             MaterializedGraph::PersistentGraph(g) => Some(g),
         }
     }
+
+    #[cfg(feature = "io")]
+    pub fn load(path: &(impl GraphPaths + ?Sized)) -> Result<Self, GraphError> {
+        let meta = path.read_metadata()?;
+        if meta.is_diskgraph {
+            match meta.graph_type {
+                GraphType::EventGraph => Ok(Self::EventGraph(Graph::load(path)?)),
+                GraphType::PersistentGraph => {
+                    Ok(Self::PersistentGraph(PersistentGraph::load(path)?))
+                }
+            }
+        } else {
+            Err(GraphError::NotADiskGraph)
+        }
+    }
+
+    #[cfg(feature = "io")]
+    pub fn load_with_config(
+        path: &(impl GraphPaths + ?Sized),
+        config: Config,
+    ) -> Result<Self, GraphError> {
+        let meta = path.read_metadata()?;
+        if meta.is_diskgraph {
+            match meta.graph_type {
+                GraphType::EventGraph => {
+                    Ok(Self::EventGraph(Graph::load_with_config(path, config)?))
+                }
+                GraphType::PersistentGraph => Ok(Self::PersistentGraph(
+                    PersistentGraph::load_with_config(path, config)?,
+                )),
+            }
+        } else {
+            Err(GraphError::NotADiskGraph)
+        }
+    }
 }
 
 impl InternalStorageOps for MaterializedGraph {
     fn get_storage(&self) -> Option<&Storage> {
         for_all!(self, g => g.get_storage())
     }
+
+    fn disk_storage_path(&self) -> Option<&Path> {
+        for_all!(self, g => g.disk_storage_path())
+    }
 }
 
 impl GraphTimeSemanticsOps for MaterializedGraph {
@@ -136,7 +178,7 @@ impl GraphTimeSemanticsOps for MaterializedGraph {
         for_all!(self, g => g.has_temporal_prop(prop_id))
     }
 
-    fn temporal_prop_iter(&self, prop_id: usize) -> BoxedLDIter<'_, (EventTime, Prop)> {
+    fn temporal_prop_iter(&self, prop_id: usize) -> BoxedLIter<'_, (EventTime, Prop)> {
         for_all!(self, g => g.temporal_prop_iter(prop_id))
     }
 
@@ -149,10 +191,19 @@ impl GraphTimeSemanticsOps for MaterializedGraph {
         prop_id: usize,
         start: EventTime,
         end: EventTime,
-    ) -> BoxedLDIter<'_, (EventTime, Prop)> {
+    ) -> BoxedLIter<'_, (EventTime, Prop)> {
         for_all!(self, g => g.temporal_prop_iter_window(prop_id, start, end))
     }
 
+    fn temporal_prop_iter_window_rev(
+        &self,
+        prop_id: usize,
+        start: EventTime,
+        end: EventTime,
+    ) -> BoxedLIter<'_, (EventTime, Prop)> {
+        for_all!(self, g => g.temporal_prop_iter_window_rev(prop_id, start, end))
+    }
+
     fn temporal_prop_last_at(&self, prop_id: usize, t: EventTime) -> Option<(EventTime, Prop)> {
         for_all!(self, g => g.temporal_prop_last_at(prop_id, t))
     }
@@ -214,7 +265,7 @@ mod test_materialised_graph_dispatch {
     #[test]
     fn materialised_graph_has_core_ops() {
         let mg = MaterializedGraph::from(Graph::new());
-        assert_eq!(mg.unfiltered_num_nodes(), 0);
+        assert_eq!(mg.unfiltered_num_nodes(&LayerIds::All), 0);
     }
 
     #[test]
@@ -247,7 +298,7 @@ mod test_materialised_graph_dispatch {
 
         let mg = g.materialize().unwrap();
 
-        let v = mg.add_node(0, 1, NO_PROPS, None).unwrap();
+        let v = mg.add_node(0, 1, NO_PROPS, None, None).unwrap();
         assert_eq!(v.id(), GID::U64(1))
     }
 }
diff --git a/raphtory/src/db/api/view/internal/mod.rs b/raphtory/src/db/api/view/internal/mod.rs
index f900944353..1c9ce86f51 100644
--- a/raphtory/src/db/api/view/internal/mod.rs
+++ b/raphtory/src/db/api/view/internal/mod.rs
@@ -12,6 +12,7 @@ use crate::{
 };
 use std::{
     fmt::{Debug, Formatter},
+    path::Path,
     sync::Arc,
 };
 
@@ -99,6 +100,10 @@ pub trait InheritStorageOps: Base {}
 
 pub trait InternalStorageOps {
     fn get_storage(&self) -> Option<&Storage>;
+
+    /// Returns the path if the underlying storage saves data to disk,
+    /// or `None` if the storage is in-memory only.
+    fn disk_storage_path(&self) -> Option<&Path>;
 }
 
 impl<G: InheritStorageOps> InternalStorageOps for G
@@ -108,6 +113,10 @@ where
     fn get_storage(&self) -> Option<&Storage> {
         self.base().get_storage()
     }
+
+    fn disk_storage_path(&self) -> Option<&Path> {
+        self.base().disk_storage_path()
+    }
 }
 
 /// Trait for marking a struct as not dynamically dispatched.
@@ -196,6 +205,8 @@ impl Base for DynamicGraph {
 
 impl Immutable for DynamicGraph {}
 
+impl<'graph> Immutable for Arc<dyn BoxableGraphView + 'graph> {}
+
 impl InheritViewOps for DynamicGraph {}
 
 impl InheritCoreGraphOps for DynamicGraph {}
@@ -235,7 +246,7 @@ mod test {
     fn test_boxing() {
         // this tests that a boxed graph actually compiles
         let g = Graph::new();
-        g.add_node(0, 1u64, NO_PROPS, None).unwrap();
+        g.add_node(0, 1u64, NO_PROPS, None, None).unwrap();
         let boxed: Arc<dyn BoxableGraphView> = Arc::new(g);
         assert_eq!(
             boxed
diff --git a/raphtory/src/db/api/view/internal/time_semantics/base_time_semantics.rs b/raphtory/src/db/api/view/internal/time_semantics/base_time_semantics.rs
index f1d7ea7867..7e395dcdcd 100644
--- a/raphtory/src/db/api/view/internal/time_semantics/base_time_semantics.rs
+++ b/raphtory/src/db/api/view/internal/time_semantics/base_time_semantics.rs
@@ -7,11 +7,12 @@ use crate::db::api::view::internal::{
 };
 use iter_enum::{DoubleEndedIterator, ExactSizeIterator, FusedIterator, Iterator};
 use raphtory_api::core::{
-    entities::{properties::prop::Prop, LayerIds, ELID},
+    entities::{properties::prop::Prop, LayerId, LayerIds, ELID},
     storage::timeindex::EventTime,
 };
-use raphtory_storage::graph::{edges::edge_ref::EdgeStorageRef, nodes::node_ref::NodeStorageRef};
+use raphtory_storage::graph::nodes::node_ref::NodeStorageRef;
 use std::ops::Range;
+use storage::EdgeEntryRef;
 
 #[derive(Copy, Clone, Debug)]
 pub enum BaseTimeSemantics {
@@ -89,8 +90,9 @@ impl NodeTimeSemanticsOps for BaseTimeSemantics {
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
     ) -> impl Iterator<Item = EventTime> + Send + Sync + 'graph {
-        for_all_iter!(self, semantics => semantics.node_history(node, view))
+        for_all_iter!(self, semantics => semantics.node_history(node, view, layer_ids))
     }
 
     #[inline]
@@ -98,8 +100,9 @@ impl NodeTimeSemanticsOps for BaseTimeSemantics {
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
     ) -> impl Iterator<Item = EventTime> + Send + Sync + 'graph {
-        for_all_iter!(self, semantics => semantics.node_history_rev(node, view))
+        for_all_iter!(self, semantics => semantics.node_history_rev(node, view, layer_ids))
     }
 
     #[inline]
@@ -107,9 +110,10 @@ impl NodeTimeSemanticsOps for BaseTimeSemantics {
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
     ) -> impl Iterator<Item = EventTime> + Send + Sync + 'graph {
-        for_all_iter!(self, semantics => semantics.node_history_window(node, view, w))
+        for_all_iter!(self, semantics => semantics.node_history_window(node, view, layer_ids, w))
     }
 
     #[inline]
@@ -117,9 +121,10 @@ impl NodeTimeSemanticsOps for BaseTimeSemantics {
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
     ) -> impl Iterator<Item = EventTime> + Send + Sync + 'graph {
-        for_all_iter!(self, semantics => semantics.node_history_window_rev(node, view, w))
+        for_all_iter!(self, semantics => semantics.node_history_window_rev(node, view, layer_ids, w))
     }
 
     #[inline]
@@ -136,8 +141,9 @@ impl NodeTimeSemanticsOps for BaseTimeSemantics {
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
     ) -> impl Iterator<Item = (EventTime, ELID)> + Send + Sync + 'graph {
-        for_all_iter!(self, semantics => semantics.node_edge_history(node, view))
+        for_all_iter!(self, semantics => semantics.node_edge_history(node, view, layer_ids))
     }
 
     #[inline]
@@ -145,9 +151,10 @@ impl NodeTimeSemanticsOps for BaseTimeSemantics {
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
     ) -> impl Iterator<Item = (EventTime, ELID)> + Send + Sync + 'graph {
-        for_all_iter!(self, semantics => semantics.node_edge_history_window(node, view, w))
+        for_all_iter!(self, semantics => semantics.node_edge_history_window(node, view, layer_ids, w))
     }
 
     #[inline]
@@ -155,8 +162,9 @@ impl NodeTimeSemanticsOps for BaseTimeSemantics {
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
     ) -> impl Iterator<Item = (EventTime, ELID)> + Send + Sync + 'graph {
-        for_all_iter!(self, semantics => semantics.node_edge_history_rev(node, view))
+        for_all_iter!(self, semantics => semantics.node_edge_history_rev(node, view, layer_ids))
     }
 
     #[inline]
@@ -164,9 +172,10 @@ impl NodeTimeSemanticsOps for BaseTimeSemantics {
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
     ) -> impl Iterator<Item = (EventTime, ELID)> + Send + Sync + 'graph {
-        for_all_iter!(self, semantics => semantics.node_edge_history_rev_window(node, view, w))
+        for_all_iter!(self, semantics => semantics.node_edge_history_rev_window(node, view, layer_ids, w))
     }
 
     #[inline]
@@ -184,7 +193,7 @@ impl NodeTimeSemanticsOps for BaseTimeSemantics {
         self,
         node: NodeStorageRef<'graph>,
         view: G,
-    ) -> impl Iterator<Item = (EventTime, Vec<(usize, Prop)>)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId, Vec<(usize, Prop)>)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.node_updates(node, view))
     }
 
@@ -194,7 +203,7 @@ impl NodeTimeSemanticsOps for BaseTimeSemantics {
         node: NodeStorageRef<'graph>,
         view: G,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, Vec<(usize, Prop)>)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId, Vec<(usize, Prop)>)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.node_updates_window(node, view, w))
     }
 
@@ -223,10 +232,20 @@ impl NodeTimeSemanticsOps for BaseTimeSemantics {
         node: NodeStorageRef<'graph>,
         view: G,
         prop_id: usize,
-    ) -> impl DoubleEndedIterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.node_tprop_iter(node, view, prop_id))
     }
 
+    #[inline]
+    fn node_tprop_iter_rev<'graph, G: GraphView + 'graph>(
+        &self,
+        node: NodeStorageRef<'graph>,
+        view: G,
+        prop_id: usize,
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
+        for_all_iter!(self, semantics => semantics.node_tprop_iter_rev(node, view, prop_id))
+    }
+
     #[inline]
     fn node_tprop_iter_window<'graph, G: GraphView + 'graph>(
         &self,
@@ -234,10 +253,21 @@ impl NodeTimeSemanticsOps for BaseTimeSemantics {
         view: G,
         prop_id: usize,
         w: Range<EventTime>,
-    ) -> impl DoubleEndedIterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.node_tprop_iter_window(node, view, prop_id, w))
     }
 
+    #[inline]
+    fn node_tprop_iter_window_rev<'graph, G: GraphView + 'graph>(
+        &self,
+        node: NodeStorageRef<'graph>,
+        view: G,
+        prop_id: usize,
+        w: Range<EventTime>,
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
+        for_all_iter!(self, semantics => semantics.node_tprop_iter_window_rev(node, view, prop_id, w))
+    }
+
     #[inline]
     fn node_tprop_last_at<'graph, G: GraphView + 'graph>(
         &self,
@@ -272,16 +302,16 @@ impl EdgeTimeSemanticsOps for BaseTimeSemantics {
         for_all!(self, semantics => semantics.handle_edge_update_filter(t, eid, view))
     }
 
-    fn include_edge<G: GraphView>(&self, edge: EdgeStorageRef, view: G, layer_id: usize) -> bool {
+    fn include_edge<G: GraphView>(&self, edge: EdgeEntryRef, view: G, layer_id: LayerId) -> bool {
         for_all!(self, semantics => semantics.include_edge(edge, view, layer_id))
     }
 
     #[inline]
     fn include_edge_window<G: GraphView>(
         &self,
-        edge: EdgeStorageRef,
+        edge: EdgeEntryRef,
         view: G,
-        layer_id: usize,
+        layer_id: LayerId,
         w: Range<EventTime>,
     ) -> bool {
         for_all!(self, semantics => semantics.include_edge_window(edge, view, layer_id, w))
@@ -304,49 +334,49 @@ impl EdgeTimeSemanticsOps for BaseTimeSemantics {
     #[inline]
     fn edge_history<'graph, G: GraphView + 'graph>(
         self,
-        edge: EdgeStorageRef<'graph>,
+        edge: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.edge_history(edge, view, layer_ids))
     }
 
     #[inline]
     fn edge_history_rev<'graph, G: GraphView + 'graph>(
         self,
-        edge: EdgeStorageRef<'graph>,
+        edge: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.edge_history_rev(edge, view, layer_ids))
     }
 
     #[inline]
     fn edge_history_window<'graph, G: GraphView + 'graph>(
         self,
-        edge: EdgeStorageRef<'graph>,
+        edge: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.edge_history_window(edge, view, layer_ids, w))
     }
 
     #[inline]
     fn edge_history_window_rev<'graph, G: GraphView + 'graph>(
         self,
-        edge: EdgeStorageRef<'graph>,
+        edge: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.edge_history_window_rev(edge, view, layer_ids, w))
     }
 
     #[inline]
     fn edge_exploded_count<'graph, G: GraphView + 'graph>(
         &self,
-        edge: EdgeStorageRef,
+        edge: EdgeEntryRef,
         view: G,
     ) -> usize {
         for_all!(self, semantics => semantics.edge_exploded_count(edge, view))
@@ -355,7 +385,7 @@ impl EdgeTimeSemanticsOps for BaseTimeSemantics {
     #[inline]
     fn edge_exploded_count_window<'graph, G: GraphView + 'graph>(
         &self,
-        edge: EdgeStorageRef,
+        edge: EdgeEntryRef,
         view: G,
         w: Range<EventTime>,
     ) -> usize {
@@ -365,49 +395,49 @@ impl EdgeTimeSemanticsOps for BaseTimeSemantics {
     #[inline]
     fn edge_exploded<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.edge_exploded(e, view, layer_ids))
     }
 
     #[inline]
     fn edge_layers<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = usize> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = LayerId> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.edge_layers(e, view, layer_ids))
     }
 
     #[inline]
     fn edge_window_exploded<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.edge_window_exploded(e, view, layer_ids, w))
     }
 
     #[inline]
     fn edge_window_layers<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = usize> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = LayerId> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.edge_window_layers(e, view, layer_ids, w))
     }
 
     #[inline]
     fn edge_earliest_time<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
     ) -> Option<EventTime> {
         for_all!(self, semantics => semantics.edge_earliest_time(e, view))
@@ -416,7 +446,7 @@ impl EdgeTimeSemanticsOps for BaseTimeSemantics {
     #[inline]
     fn edge_earliest_time_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         w: Range<EventTime>,
     ) -> Option<EventTime> {
@@ -426,10 +456,10 @@ impl EdgeTimeSemanticsOps for BaseTimeSemantics {
     #[inline]
     fn edge_exploded_earliest_time<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
     ) -> Option<EventTime> {
         for_all!(self, semantics => semantics.edge_exploded_earliest_time(e, view, t, layer))
     }
@@ -437,10 +467,10 @@ impl EdgeTimeSemanticsOps for BaseTimeSemantics {
     #[inline]
     fn edge_exploded_earliest_time_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
         w: Range<EventTime>,
     ) -> Option<EventTime> {
         for_all!(self, semantics => semantics.edge_exploded_earliest_time_window(e, view, t, layer, w))
@@ -449,7 +479,7 @@ impl EdgeTimeSemanticsOps for BaseTimeSemantics {
     #[inline]
     fn edge_latest_time<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
     ) -> Option<EventTime> {
         for_all!(self, semantics => semantics.edge_latest_time(e, view))
@@ -458,7 +488,7 @@ impl EdgeTimeSemanticsOps for BaseTimeSemantics {
     #[inline]
     fn edge_latest_time_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         w: Range<EventTime>,
     ) -> Option<EventTime> {
@@ -468,10 +498,10 @@ impl EdgeTimeSemanticsOps for BaseTimeSemantics {
     #[inline]
     fn edge_exploded_latest_time<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
     ) -> Option<EventTime> {
         for_all!(self, semantics => semantics.edge_exploded_latest_time(e, view, t, layer))
     }
@@ -479,10 +509,10 @@ impl EdgeTimeSemanticsOps for BaseTimeSemantics {
     #[inline]
     fn edge_exploded_latest_time_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
         w: Range<EventTime>,
     ) -> Option<EventTime> {
         for_all!(self, semantics => semantics.edge_exploded_latest_time_window(e, view, t, layer, w))
@@ -491,49 +521,49 @@ impl EdgeTimeSemanticsOps for BaseTimeSemantics {
     #[inline]
     fn edge_deletion_history<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.edge_deletion_history(e, view, layer_ids))
     }
 
     #[inline]
     fn edge_deletion_history_rev<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.edge_deletion_history_rev(e, view, layer_ids))
     }
 
     #[inline]
     fn edge_deletion_history_window<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.edge_deletion_history_window(e, view, layer_ids, w))
     }
 
     #[inline]
     fn edge_deletion_history_window_rev<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.edge_deletion_history_window_rev(e, view, layer_ids, w))
     }
 
     #[inline]
     fn edge_is_valid<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
     ) -> bool {
         for_all!(self, semantics => semantics.edge_is_valid(e, view))
@@ -542,7 +572,7 @@ impl EdgeTimeSemanticsOps for BaseTimeSemantics {
     #[inline]
     fn edge_is_valid_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         r: Range<EventTime>,
     ) -> bool {
@@ -552,7 +582,7 @@ impl EdgeTimeSemanticsOps for BaseTimeSemantics {
     #[inline]
     fn edge_is_deleted<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
     ) -> bool {
         for_all!(self, semantics => semantics.edge_is_deleted(e, view))
@@ -561,7 +591,7 @@ impl EdgeTimeSemanticsOps for BaseTimeSemantics {
     #[inline]
     fn edge_is_deleted_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         w: Range<EventTime>,
     ) -> bool {
@@ -571,7 +601,7 @@ impl EdgeTimeSemanticsOps for BaseTimeSemantics {
     #[inline]
     fn edge_is_active<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
     ) -> bool {
         for_all!(self, semantics => semantics.edge_is_active(e, view))
@@ -580,7 +610,7 @@ impl EdgeTimeSemanticsOps for BaseTimeSemantics {
     #[inline]
     fn edge_is_active_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         w: Range<EventTime>,
     ) -> bool {
@@ -590,10 +620,10 @@ impl EdgeTimeSemanticsOps for BaseTimeSemantics {
     #[inline]
     fn edge_is_active_exploded<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
     ) -> bool {
         for_all!(self, semantics => semantics.edge_is_active_exploded(e, view, t, layer))
     }
@@ -601,10 +631,10 @@ impl EdgeTimeSemanticsOps for BaseTimeSemantics {
     #[inline]
     fn edge_is_active_exploded_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
         w: Range<EventTime>,
     ) -> bool {
         for_all!(self, semantics => semantics.edge_is_active_exploded_window(e, view, t, layer, w))
@@ -613,10 +643,10 @@ impl EdgeTimeSemanticsOps for BaseTimeSemantics {
     #[inline]
     fn edge_is_valid_exploded<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
     ) -> bool {
         for_all!(self, semantics => semantics.edge_is_valid_exploded(e, view, t, layer))
     }
@@ -624,10 +654,10 @@ impl EdgeTimeSemanticsOps for BaseTimeSemantics {
     #[inline]
     fn edge_is_valid_exploded_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
         w: Range<EventTime>,
     ) -> bool {
         for_all!(self, semantics => semantics.edge_is_valid_exploded_window(e, view, t, layer, w))
@@ -636,10 +666,10 @@ impl EdgeTimeSemanticsOps for BaseTimeSemantics {
     #[inline]
     fn edge_exploded_deletion<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
     ) -> Option<EventTime> {
         for_all!(self, semantics => semantics.edge_exploded_deletion(e, view, t, layer))
     }
@@ -647,10 +677,10 @@ impl EdgeTimeSemanticsOps for BaseTimeSemantics {
     #[inline]
     fn edge_exploded_deletion_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
         w: Range<EventTime>,
     ) -> Option<EventTime> {
         for_all!(self, semantics => semantics.edge_exploded_deletion_window(e, view, t, layer, w))
@@ -659,11 +689,11 @@ impl EdgeTimeSemanticsOps for BaseTimeSemantics {
     #[inline]
     fn temporal_edge_prop_exploded<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         prop_id: usize,
         t: EventTime,
-        layer_id: usize,
+        layer_id: LayerId,
     ) -> Option<Prop> {
         for_all!(self, semantics => semantics.temporal_edge_prop_exploded(e, view, prop_id, t, layer_id))
     }
@@ -671,10 +701,10 @@ impl EdgeTimeSemanticsOps for BaseTimeSemantics {
     #[inline]
     fn temporal_edge_prop_exploded_last_at<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         edge_time: EventTime,
-        layer_id: usize,
+        layer_id: LayerId,
         prop_id: usize,
         at: EventTime,
     ) -> Option<Prop> {
@@ -684,10 +714,10 @@ impl EdgeTimeSemanticsOps for BaseTimeSemantics {
     #[inline]
     fn temporal_edge_prop_exploded_last_at_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         edge_time: EventTime,
-        layer_id: usize,
+        layer_id: LayerId,
         prop_id: usize,
         at: EventTime,
         w: Range<EventTime>,
@@ -698,7 +728,7 @@ impl EdgeTimeSemanticsOps for BaseTimeSemantics {
     #[inline]
     fn temporal_edge_prop_last_at<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         prop_id: usize,
         t: EventTime,
@@ -709,7 +739,7 @@ impl EdgeTimeSemanticsOps for BaseTimeSemantics {
     #[inline]
     fn temporal_edge_prop_last_at_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         prop_id: usize,
         t: EventTime,
@@ -721,53 +751,53 @@ impl EdgeTimeSemanticsOps for BaseTimeSemantics {
     #[inline]
     fn temporal_edge_prop_hist<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         prop_id: usize,
-    ) -> impl Iterator<Item = (EventTime, usize, Prop)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId, Prop)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.temporal_edge_prop_hist(e, view, layer_ids, prop_id))
     }
 
     #[inline]
     fn temporal_edge_prop_hist_rev<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         prop_id: usize,
-    ) -> impl Iterator<Item = (EventTime, usize, Prop)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId, Prop)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.temporal_edge_prop_hist_rev(e, view,layer_ids, prop_id))
     }
 
     #[inline]
     fn temporal_edge_prop_hist_window<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         prop_id: usize,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize, Prop)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId, Prop)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.temporal_edge_prop_hist_window(e, view, layer_ids, prop_id, w))
     }
 
     #[inline]
     fn temporal_edge_prop_hist_window_rev<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         prop_id: usize,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize, Prop)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId, Prop)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.temporal_edge_prop_hist_window_rev(e, view, layer_ids, prop_id, w))
     }
 
     #[inline]
     fn edge_metadata<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         prop_id: usize,
     ) -> Option<Prop> {
@@ -777,7 +807,7 @@ impl EdgeTimeSemanticsOps for BaseTimeSemantics {
     #[inline]
     fn edge_metadata_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         prop_id: usize,
         w: Range<EventTime>,
diff --git a/raphtory/src/db/api/view/internal/time_semantics/event_semantics.rs b/raphtory/src/db/api/view/internal/time_semantics/event_semantics.rs
index d1437cb173..81db1c874b 100644
--- a/raphtory/src/db/api/view/internal/time_semantics/event_semantics.rs
+++ b/raphtory/src/db/api/view/internal/time_semantics/event_semantics.rs
@@ -10,15 +10,16 @@ use itertools::Itertools;
 use raphtory_api::core::{
     entities::{
         properties::{prop::Prop, tprop::TPropOps},
-        LayerIds, ELID,
+        LayerId, LayerIds, ELID,
     },
     storage::timeindex::{EventTime, TimeIndexOps},
 };
 use raphtory_storage::graph::{
-    edges::{edge_ref::EdgeStorageRef, edge_storage_ops::EdgeStorageOps},
+    edges::edge_storage_ops::EdgeStorageOps,
     nodes::{node_ref::NodeStorageRef, node_storage_ops::NodeStorageOps},
 };
 use std::ops::Range;
+use storage::EdgeEntryRef;
 
 #[derive(Debug, Copy, Clone)]
 pub struct EventSemantics;
@@ -29,7 +30,7 @@ impl NodeTimeSemanticsOps for EventSemantics {
         node: NodeStorageRef<'graph>,
         view: G,
     ) -> Option<EventTime> {
-        node.history(view).first()
+        node.history(&view, view.layer_ids()).first()
     }
 
     fn node_latest_time<'graph, G: GraphView + 'graph>(
@@ -37,7 +38,7 @@ impl NodeTimeSemanticsOps for EventSemantics {
         node: NodeStorageRef<'graph>,
         view: G,
     ) -> Option<EventTime> {
-        node.history(view).last()
+        node.history(&view, view.layer_ids()).last()
     }
 
     fn node_earliest_time_window<'graph, G: GraphView + 'graph>(
@@ -46,7 +47,7 @@ impl NodeTimeSemanticsOps for EventSemantics {
         view: G,
         w: Range<EventTime>,
     ) -> Option<EventTime> {
-        node.history(view).range(w).first()
+        node.history(&view, view.layer_ids()).range(w).first()
     }
 
     fn node_latest_time_window<'graph, G: GraphView + 'graph>(
@@ -55,41 +56,45 @@ impl NodeTimeSemanticsOps for EventSemantics {
         view: G,
         w: Range<EventTime>,
     ) -> Option<EventTime> {
-        node.history(view).range(w).last()
+        node.history(&view, view.layer_ids()).range(w).last()
     }
 
     fn node_history<'graph, G: GraphView + 'graph>(
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
     ) -> impl Iterator<Item = EventTime> + Send + Sync + 'graph {
-        node.history(view).iter()
+        node.history(view, layer_ids).iter()
     }
 
     fn node_history_rev<'graph, G: GraphView + 'graph>(
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
     ) -> impl Iterator<Item = EventTime> + Send + Sync + 'graph {
-        node.history(view).iter_rev()
+        node.history(view, layer_ids).iter_rev()
     }
 
     fn node_history_window<'graph, G: GraphView + 'graph>(
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
     ) -> impl Iterator<Item = EventTime> + Send + Sync + 'graph {
-        node.history(view).range(w).iter()
+        node.history(view, layer_ids).range(w).iter()
     }
 
     fn node_history_window_rev<'graph, G: GraphView + 'graph>(
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
     ) -> impl Iterator<Item = EventTime> + Send + Sync + 'graph {
-        node.history(view).range(w).iter_rev()
+        node.history(view, layer_ids).range(w).iter_rev()
     }
 
     fn node_edge_history_count<'graph, G: GraphView + 'graph>(
@@ -97,7 +102,7 @@ impl NodeTimeSemanticsOps for EventSemantics {
         node: NodeStorageRef<'graph>,
         view: G,
     ) -> usize {
-        node.history(view).edge_history().len()
+        node.history(&view, view.layer_ids()).edge_history().len()
     }
 
     fn node_edge_history_count_window<'graph, G: GraphView + 'graph>(
@@ -106,56 +111,57 @@ impl NodeTimeSemanticsOps for EventSemantics {
         view: G,
         w: Range<EventTime>,
     ) -> usize {
-        node.history(view).range(w).edge_history().len()
+        node.history(&view, view.layer_ids())
+            .range(w)
+            .edge_history()
+            .len()
     }
 
     fn node_edge_history<'graph, G: GraphView + 'graph>(
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
     ) -> impl Iterator<Item = (EventTime, ELID)> + Send + Sync + 'graph {
-        node.edge_history(view).history()
+        node.edge_history(view, layer_ids).history()
     }
 
     fn node_edge_history_window<'graph, G: GraphView + 'graph>(
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
     ) -> impl Iterator<Item = (EventTime, ELID)> + Send + Sync + 'graph {
-        node.edge_history(view).range(w).history()
+        node.edge_history(view, layer_ids).range(w).history()
     }
 
     fn node_edge_history_rev<'graph, G: GraphView + 'graph>(
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
     ) -> impl Iterator<Item = (EventTime, ELID)> + Send + Sync + 'graph {
-        node.edge_history(view).history_rev()
+        node.edge_history(view, layer_ids).history_rev()
     }
 
     fn node_edge_history_rev_window<'graph, G: GraphView + 'graph>(
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
     ) -> impl Iterator<Item = (EventTime, ELID)> + Send + Sync + 'graph {
-        node.edge_history(view).range(w).history_rev()
+        node.edge_history(view, layer_ids).range(w).history_rev()
     }
 
     fn node_updates<'graph, G: GraphView + 'graph>(
         self,
         node: NodeStorageRef<'graph>,
         _view: G,
-    ) -> impl Iterator<Item = (EventTime, Vec<(usize, Prop)>)> + Send + Sync + 'graph {
-        node.temp_prop_rows().map(|(t, row)| {
-            (
-                t,
-                row.into_iter()
-                    .filter_map(|(id, prop)| Some((id, prop?)))
-                    .collect(),
-            )
-        })
+    ) -> impl Iterator<Item = (EventTime, LayerId, Vec<(usize, Prop)>)> + Send + Sync + 'graph {
+        node.temp_prop_rows()
+            .map(|(t, l, row)| (t, LayerId(l), row))
     }
 
     fn node_updates_window<'graph, G: GraphView + 'graph>(
@@ -163,15 +169,9 @@ impl NodeTimeSemanticsOps for EventSemantics {
         node: NodeStorageRef<'graph>,
         _view: G,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, Vec<(usize, Prop)>)> + Send + Sync + 'graph {
-        node.temp_prop_rows_window(w).map(|(t, row)| {
-            (
-                t,
-                row.into_iter()
-                    .filter_map(|(id, prop)| Some((id, prop?)))
-                    .collect(),
-            )
-        })
+    ) -> impl Iterator<Item = (EventTime, LayerId, Vec<(usize, Prop)>)> + Send + Sync + 'graph {
+        node.temp_prop_rows_range(Some(w))
+            .map(|(t, l, row)| (t, LayerId(l), row))
     }
 
     fn node_valid<'graph, G: GraphView + 'graph>(
@@ -179,7 +179,7 @@ impl NodeTimeSemanticsOps for EventSemantics {
         node: NodeStorageRef<'graph>,
         view: G,
     ) -> bool {
-        !node.history(view).is_empty()
+        !node.history(&view, view.layer_ids()).is_empty()
     }
 
     fn node_valid_window<'graph, G: GraphView + 'graph>(
@@ -188,50 +188,79 @@ impl NodeTimeSemanticsOps for EventSemantics {
         view: G,
         w: Range<EventTime>,
     ) -> bool {
-        node.history(view).active(w)
+        node.history(&view, view.layer_ids()).active(w)
     }
 
     fn node_tprop_iter<'graph, G: GraphView + 'graph>(
         &self,
         node: NodeStorageRef<'graph>,
-        _view: G,
+        view: G,
+        prop_id: usize,
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
+        node.tprop_iter_layers(view.layer_ids(), prop_id)
+            .map(|p| p.iter())
+            .kmerge_by(|(a, _), (b, _)| a <= b)
+    }
+
+    fn node_tprop_iter_rev<'graph, G: GraphView + 'graph>(
+        &self,
+        node: NodeStorageRef<'graph>,
+        view: G,
         prop_id: usize,
-    ) -> impl DoubleEndedIterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
-        node.tprop(prop_id).iter()
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
+        node.tprop_iter_layers(view.layer_ids(), prop_id)
+            .map(|p| p.iter_rev())
+            .kmerge_by(|(a, _), (b, _)| a >= b)
     }
 
     fn node_tprop_iter_window<'graph, G: GraphView + 'graph>(
         &self,
         node: NodeStorageRef<'graph>,
-        _view: G,
+        view: G,
         prop_id: usize,
         w: Range<EventTime>,
-    ) -> impl DoubleEndedIterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
-        node.tprop(prop_id).iter_window(w)
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
+        node.tprop_iter_layers(view.layer_ids(), prop_id)
+            .map(move |p| p.iter_window(w.clone()))
+            .kmerge_by(|(a, _), (b, _)| a <= b)
+    }
+
+    fn node_tprop_iter_window_rev<'graph, G: GraphView + 'graph>(
+        &self,
+        node: NodeStorageRef<'graph>,
+        view: G,
+        prop_id: usize,
+        w: Range<EventTime>,
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
+        node.tprop_iter_layers(view.layer_ids(), prop_id)
+            .map(move |p| p.iter_window_rev(w.clone()))
+            .kmerge_by(|(a, _), (b, _)| a >= b)
     }
 
     fn node_tprop_last_at<'graph, G: GraphView + 'graph>(
         &self,
         node: NodeStorageRef<'graph>,
-        _view: G,
+        view: G,
         prop_id: usize,
         t: EventTime,
     ) -> Option<(EventTime, Prop)> {
-        let prop = node.tprop(prop_id);
-        prop.last_before(t.next())
+        node.tprop_iter_layers(view.layer_ids(), prop_id)
+            .filter_map(|prop| prop.last_before(t.next()))
+            .max_by_key(|(t, _)| *t)
     }
 
     fn node_tprop_last_at_window<'graph, G: GraphView + 'graph>(
         &self,
         node: NodeStorageRef<'graph>,
-        _view: G,
+        view: G,
         prop_id: usize,
         t: EventTime,
         w: Range<EventTime>,
     ) -> Option<(EventTime, Prop)> {
         if w.contains(&t) {
-            let prop = node.tprop(prop_id);
-            prop.last_before(t.next()).filter(|(t, _)| w.contains(t))
+            node.tprop_iter_layers(view.layer_ids(), prop_id)
+                .filter_map(|prop| prop.last_before(t.next()).filter(|(t, _)| w.contains(t)))
+                .max_by_key(|(t, _)| *t)
         } else {
             None
         }
@@ -248,16 +277,16 @@ impl EdgeTimeSemanticsOps for EventSemantics {
         view.filter_exploded_edge_inner(eid, t).then_some((t, eid))
     }
 
-    fn include_edge<G: GraphView>(&self, edge: EdgeStorageRef, view: G, layer_id: usize) -> bool {
+    fn include_edge<G: GraphView>(&self, edge: EdgeEntryRef, view: G, layer_id: LayerId) -> bool {
         !edge.filtered_additions(layer_id, &view).is_empty()
             || !edge.filtered_deletions(layer_id, &view).is_empty()
     }
 
     fn include_edge_window<G: GraphView>(
         &self,
-        edge: EdgeStorageRef,
+        edge: EdgeEntryRef,
         view: G,
-        layer_id: usize,
+        layer_id: LayerId,
         w: Range<EventTime>,
     ) -> bool {
         edge.filtered_additions(layer_id, &view).active(w.clone())
@@ -290,10 +319,10 @@ impl EdgeTimeSemanticsOps for EventSemantics {
 
     fn edge_history<'graph, G: GraphView + 'graph>(
         self,
-        edge: EdgeStorageRef<'graph>,
+        edge: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         edge.filtered_additions_iter(view, layer_ids)
             .map(|(layer_id, additions)| additions.iter().map(move |t| (t, layer_id)))
             .kmerge()
@@ -301,10 +330,10 @@ impl EdgeTimeSemanticsOps for EventSemantics {
 
     fn edge_history_rev<'graph, G: GraphView + 'graph>(
         self,
-        edge: EdgeStorageRef<'graph>,
+        edge: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         edge.filtered_additions_iter(view, layer_ids)
             .map(|(layer_id, additions)| additions.iter_rev().map(move |t| (t, layer_id)))
             .kmerge_by(|a, b| a >= b)
@@ -312,11 +341,11 @@ impl EdgeTimeSemanticsOps for EventSemantics {
 
     fn edge_history_window<'graph, G: GraphView + 'graph>(
         self,
-        edge: EdgeStorageRef<'graph>,
+        edge: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         edge.filtered_additions_iter(view, layer_ids)
             .map(move |(layer_id, additions)| {
                 additions
@@ -329,11 +358,11 @@ impl EdgeTimeSemanticsOps for EventSemantics {
 
     fn edge_history_window_rev<'graph, G: GraphView + 'graph>(
         self,
-        edge: EdgeStorageRef<'graph>,
+        edge: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         edge.filtered_additions_iter(view, layer_ids)
             .map(move |(layer_id, additions)| {
                 additions
@@ -346,7 +375,7 @@ impl EdgeTimeSemanticsOps for EventSemantics {
 
     fn edge_exploded_count<'graph, G: GraphView + 'graph>(
         &self,
-        edge: EdgeStorageRef,
+        edge: EdgeEntryRef,
         view: G,
     ) -> usize {
         edge.filtered_additions_iter(&view, view.layer_ids())
@@ -356,7 +385,7 @@ impl EdgeTimeSemanticsOps for EventSemantics {
 
     fn edge_exploded_count_window<'graph, G: GraphView + 'graph>(
         &self,
-        edge: EdgeStorageRef,
+        edge: EdgeEntryRef,
         view: G,
         w: Range<EventTime>,
     ) -> usize {
@@ -367,19 +396,19 @@ impl EdgeTimeSemanticsOps for EventSemantics {
 
     fn edge_exploded<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         self.edge_history(e, view, layer_ids)
     }
 
     fn edge_layers<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = usize> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = LayerId> + Send + Sync + 'graph {
         if view.filtered() {
             Either::Left(e.filtered_updates_iter(view, layer_ids).filter_map(
                 move |(layer_id, additions, deletions)| {
@@ -397,21 +426,21 @@ impl EdgeTimeSemanticsOps for EventSemantics {
 
     fn edge_window_exploded<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         self.edge_history_window(e, view, layer_ids, w)
     }
 
     fn edge_window_layers<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = usize> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = LayerId> + Send + Sync + 'graph {
         e.filtered_updates_iter(view, layer_ids).filter_map(
             move |(layer_id, additions, deletions)| {
                 (additions.active(w.clone()) || deletions.active(w.clone())).then_some(layer_id)
@@ -421,7 +450,7 @@ impl EdgeTimeSemanticsOps for EventSemantics {
 
     fn edge_earliest_time<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
     ) -> Option<EventTime> {
         e.filtered_additions_iter(&view, view.layer_ids())
@@ -435,7 +464,7 @@ impl EdgeTimeSemanticsOps for EventSemantics {
 
     fn edge_earliest_time_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         w: Range<EventTime>,
     ) -> Option<EventTime> {
@@ -450,10 +479,10 @@ impl EdgeTimeSemanticsOps for EventSemantics {
 
     fn edge_exploded_earliest_time<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
     ) -> Option<EventTime> {
         view.internal_filter_exploded_edge(e.eid().with_layer(layer), t, view.layer_ids())
             .then_some(t)
@@ -461,10 +490,10 @@ impl EdgeTimeSemanticsOps for EventSemantics {
 
     fn edge_exploded_earliest_time_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
         w: Range<EventTime>,
     ) -> Option<EventTime> {
         if !w.contains(&t) {
@@ -475,7 +504,7 @@ impl EdgeTimeSemanticsOps for EventSemantics {
 
     fn edge_latest_time<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
     ) -> Option<EventTime> {
         e.filtered_additions_iter(&view, view.layer_ids())
@@ -489,7 +518,7 @@ impl EdgeTimeSemanticsOps for EventSemantics {
 
     fn edge_latest_time_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         w: Range<EventTime>,
     ) -> Option<EventTime> {
@@ -504,20 +533,20 @@ impl EdgeTimeSemanticsOps for EventSemantics {
 
     fn edge_exploded_latest_time<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
     ) -> Option<EventTime> {
         self.edge_exploded_earliest_time(e, view, t, layer)
     }
 
     fn edge_exploded_latest_time_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
         w: Range<EventTime>,
     ) -> Option<EventTime> {
         self.edge_exploded_earliest_time_window(e, view, t, layer, w)
@@ -525,10 +554,10 @@ impl EdgeTimeSemanticsOps for EventSemantics {
 
     fn edge_deletion_history<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         e.filtered_deletions_iter(view, layer_ids)
             .map(|(layer_id, t)| t.iter().map(move |t| (t, layer_id)))
             .kmerge()
@@ -536,10 +565,10 @@ impl EdgeTimeSemanticsOps for EventSemantics {
 
     fn edge_deletion_history_rev<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         e.filtered_deletions_iter(view, layer_ids)
             .map(|(layer_id, t)| t.iter_rev().map(move |t| (t, layer_id)))
             .kmerge_by(|(t1, _), (t2, _)| t1 >= t2)
@@ -547,11 +576,11 @@ impl EdgeTimeSemanticsOps for EventSemantics {
 
     fn edge_deletion_history_window<'graph, G: GraphView + 'graph>(
         self,
-        edge: EdgeStorageRef<'graph>,
+        edge: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         edge.filtered_deletions_iter(view, layer_ids)
             .map(move |(layer_id, additions)| {
                 additions
@@ -564,11 +593,11 @@ impl EdgeTimeSemanticsOps for EventSemantics {
 
     fn edge_deletion_history_window_rev<'graph, G: GraphView + 'graph>(
         self,
-        edge: EdgeStorageRef<'graph>,
+        edge: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         edge.filtered_deletions_iter(view, layer_ids)
             .map(move |(layer_id, additions)| {
                 additions
@@ -582,7 +611,7 @@ impl EdgeTimeSemanticsOps for EventSemantics {
     /// An edge is valid with event semantics if it has at least one addition event in the current view
     fn edge_is_valid<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
     ) -> bool {
         e.filtered_additions_iter(&view, view.layer_ids())
@@ -592,7 +621,7 @@ impl EdgeTimeSemanticsOps for EventSemantics {
     /// An edge is valid in a window with event semantics if it has at least one addition event in the current view in the window
     fn edge_is_valid_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         w: Range<EventTime>,
     ) -> bool {
@@ -603,7 +632,7 @@ impl EdgeTimeSemanticsOps for EventSemantics {
     /// An edge is deleted with event semantics if it has at least one deletion event in the current view
     fn edge_is_deleted<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
     ) -> bool {
         e.filtered_deletions_iter(&view, view.layer_ids())
@@ -613,7 +642,7 @@ impl EdgeTimeSemanticsOps for EventSemantics {
     /// An edge is deleted in a window with event semantics if it has at least one deletion event in the current view in the window
     fn edge_is_deleted_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         w: Range<EventTime>,
     ) -> bool {
@@ -624,7 +653,7 @@ impl EdgeTimeSemanticsOps for EventSemantics {
     /// An edge is valid with event semantics if it has at least one event in the current view
     fn edge_is_active<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
     ) -> bool {
         self.edge_is_valid(e, &view) || self.edge_is_deleted(e, &view)
@@ -633,7 +662,7 @@ impl EdgeTimeSemanticsOps for EventSemantics {
     /// An edge is active in a window with event semantics if it has at least one event in the current view in the window
     fn edge_is_active_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         w: Range<EventTime>,
     ) -> bool {
@@ -642,20 +671,20 @@ impl EdgeTimeSemanticsOps for EventSemantics {
 
     fn edge_is_active_exploded<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
     ) -> bool {
         view.internal_filter_exploded_edge(e.eid().with_layer(layer), t, view.layer_ids())
     }
 
     fn edge_is_active_exploded_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
         w: Range<EventTime>,
     ) -> bool {
         w.contains(&t)
@@ -666,10 +695,10 @@ impl EdgeTimeSemanticsOps for EventSemantics {
     /// (i.e., it's corresponding event is part of the view)
     fn edge_is_valid_exploded<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
     ) -> bool {
         self.edge_is_active_exploded(e, view, t, layer)
     }
@@ -678,10 +707,10 @@ impl EdgeTimeSemanticsOps for EventSemantics {
     /// (i.e., it's corresponding event is part of the view)
     fn edge_is_valid_exploded_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
         w: Range<EventTime>,
     ) -> bool {
         self.edge_is_active_exploded_window(e, view, t, layer, w)
@@ -689,20 +718,20 @@ impl EdgeTimeSemanticsOps for EventSemantics {
 
     fn edge_exploded_deletion<'graph, G: GraphView + 'graph>(
         &self,
-        _e: EdgeStorageRef<'graph>,
+        _e: EdgeEntryRef<'graph>,
         _view: G,
         _t: EventTime,
-        _layer: usize,
+        _layer: LayerId,
     ) -> Option<EventTime> {
         None
     }
 
     fn edge_exploded_deletion_window<'graph, G: GraphView + 'graph>(
         &self,
-        _e: EdgeStorageRef<'graph>,
+        _e: EdgeEntryRef<'graph>,
         _view: G,
         _t: EventTime,
-        _layer: usize,
+        _layer: LayerId,
         _w: Range<EventTime>,
     ) -> Option<EventTime> {
         None
@@ -710,11 +739,11 @@ impl EdgeTimeSemanticsOps for EventSemantics {
 
     fn temporal_edge_prop_exploded<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         prop_id: usize,
         t: EventTime,
-        layer_id: usize,
+        layer_id: LayerId,
     ) -> Option<Prop> {
         let eid = e.eid();
         if view.internal_filter_exploded_edge(eid.with_layer(layer_id), t, view.layer_ids()) {
@@ -726,10 +755,10 @@ impl EdgeTimeSemanticsOps for EventSemantics {
 
     fn temporal_edge_prop_exploded_last_at<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         edge_time: EventTime,
-        layer_id: usize,
+        layer_id: LayerId,
         prop_id: usize,
         at: EventTime,
     ) -> Option<Prop> {
@@ -742,10 +771,10 @@ impl EdgeTimeSemanticsOps for EventSemantics {
 
     fn temporal_edge_prop_exploded_last_at_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         edge_time: EventTime,
-        layer_id: usize,
+        layer_id: LayerId,
         prop_id: usize,
         at: EventTime,
         w: Range<EventTime>,
@@ -759,7 +788,7 @@ impl EdgeTimeSemanticsOps for EventSemantics {
 
     fn temporal_edge_prop_last_at<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         prop_id: usize,
         t: EventTime,
@@ -772,7 +801,7 @@ impl EdgeTimeSemanticsOps for EventSemantics {
 
     fn temporal_edge_prop_last_at_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         prop_id: usize,
         t: EventTime,
@@ -790,11 +819,11 @@ impl EdgeTimeSemanticsOps for EventSemantics {
 
     fn temporal_edge_prop_hist<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         prop_id: usize,
-    ) -> impl Iterator<Item = (EventTime, usize, Prop)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId, Prop)> + Send + Sync + 'graph {
         e.filtered_temporal_prop_iter(prop_id, view, layer_ids)
             .map(|(layer_id, prop)| prop.iter().map(move |(t, v)| (t, layer_id, v)))
             .kmerge_by(|(t1, _, _), (t2, _, _)| t1 <= t2)
@@ -802,24 +831,27 @@ impl EdgeTimeSemanticsOps for EventSemantics {
 
     fn temporal_edge_prop_hist_rev<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         prop_id: usize,
-    ) -> impl Iterator<Item = (EventTime, usize, Prop)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId, Prop)> + Send + Sync + 'graph {
         e.filtered_temporal_prop_iter(prop_id, view, layer_ids)
-            .map(|(layer_id, prop)| prop.iter().rev().map(move |(t, v)| (t, layer_id, v)))
+            .map(|(layer_id, prop)| {
+                prop.iter_inner_rev(None)
+                    .map(move |(t, v)| (t, layer_id, v))
+            })
             .kmerge_by(|(t1, _, _), (t2, _, _)| t1 >= t2)
     }
 
     fn temporal_edge_prop_hist_window<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         prop_id: usize,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize, Prop)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId, Prop)> + Send + Sync + 'graph {
         e.filtered_temporal_prop_iter(prop_id, view, layer_ids)
             .map(move |(layer_id, prop)| {
                 prop.iter_window(w.clone())
@@ -830,16 +862,15 @@ impl EdgeTimeSemanticsOps for EventSemantics {
 
     fn temporal_edge_prop_hist_window_rev<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         prop_id: usize,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize, Prop)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId, Prop)> + Send + Sync + 'graph {
         e.filtered_temporal_prop_iter(prop_id, view, layer_ids)
             .map(move |(layer_id, prop)| {
-                prop.iter_window(w.clone())
-                    .rev()
+                prop.iter_window_rev(w.clone())
                     .map(move |(t, v)| (t, layer_id, v))
             })
             .kmerge_by(|(t1, _, _), (t2, _, _)| t1 >= t2)
@@ -847,7 +878,7 @@ impl EdgeTimeSemanticsOps for EventSemantics {
 
     fn edge_metadata<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         prop_id: usize,
     ) -> Option<Prop> {
@@ -860,7 +891,7 @@ impl EdgeTimeSemanticsOps for EventSemantics {
 
     fn edge_metadata_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         prop_id: usize,
         w: Range<EventTime>,
diff --git a/raphtory/src/db/api/view/internal/time_semantics/filtered_edge.rs b/raphtory/src/db/api/view/internal/time_semantics/filtered_edge.rs
index 96530f2fd3..b411e0b85a 100644
--- a/raphtory/src/db/api/view/internal/time_semantics/filtered_edge.rs
+++ b/raphtory/src/db/api/view/internal/time_semantics/filtered_edge.rs
@@ -6,41 +6,42 @@ use either::Either;
 use raphtory_api::core::{
     entities::{
         properties::{prop::Prop, tprop::TPropOps},
-        LayerIds, ELID,
+        LayerId, LayerIds, ELID,
     },
     storage::timeindex::{EventTime, TimeIndexOps},
 };
-use raphtory_storage::graph::edges::{
-    edge_ref::EdgeStorageRef,
-    edge_storage_ops::{EdgeStorageOps, TimeIndexRef},
-    edges::EdgesStorage,
-};
+use raphtory_storage::graph::edges::{edge_storage_ops::EdgeStorageOps, edges::EdgesStorage};
 use rayon::iter::ParallelIterator;
-use std::{iter, ops::Range};
+use std::{iter, marker::PhantomData, ops::Range};
+use storage::{EdgeAdditions, EdgeDeletions, EdgeEntryRef};
 
 #[derive(Clone)]
-pub struct FilteredEdgeTimeIndex<'graph, G> {
+pub struct FilteredEdgeTimeIndex<'graph, G, TS> {
     eid: ELID,
-    time_index: TimeIndexRef<'graph>,
+    time_index: TS,
     view: G,
+    _marker: PhantomData<&'graph ()>,
 }
 
-impl<'graph, G> FilteredEdgeTimeIndex<'graph, G> {
-    pub fn invert(self) -> InvertedFilteredEdgeTimeIndex<'graph, G> {
+impl<'a, TS: TimeIndexOps<'a, IndexType = EventTime, RangeType = TS>, G: GraphView + 'a>
+    FilteredEdgeTimeIndex<'a, G, TS>
+{
+    pub fn invert(self) -> InvertedFilteredEdgeTimeIndex<'a, G, TS> {
         InvertedFilteredEdgeTimeIndex {
             eid: self.eid,
             time_index: self.time_index,
             view: self.view,
+            _marker: Default::default(),
         }
     }
 
-    pub fn unfiltered(&self) -> TimeIndexRef<'graph> {
+    pub fn unfiltered(&self) -> TS {
         self.time_index.clone()
     }
 }
 
-impl<'a, 'graph: 'a, G: GraphViewOps<'graph>> TimeIndexOps<'a>
-    for FilteredEdgeTimeIndex<'graph, G>
+impl<'a, TS: TimeIndexOps<'a, IndexType = EventTime, RangeType = TS>, G: GraphView + 'a>
+    TimeIndexOps<'a> for FilteredEdgeTimeIndex<'a, G, TS>
 {
     type IndexType = EventTime;
     type RangeType = Self;
@@ -66,6 +67,7 @@ impl<'a, 'graph: 'a, G: GraphViewOps<'graph>> TimeIndexOps<'a>
             eid: self.eid,
             time_index: self.time_index.range(w),
             view: self.view.clone(),
+            _marker: std::marker::PhantomData,
         }
     }
 
@@ -99,22 +101,31 @@ impl<'a, 'graph: 'a, G: GraphViewOps<'graph>> TimeIndexOps<'a>
 
     fn len(&self) -> usize {
         if self.view.internal_exploded_edge_filtered() {
-            self.iter().count()
+            self.clone().iter().count()
         } else {
             self.time_index.len()
         }
     }
+
+    fn is_empty(&self) -> bool {
+        if self.view.internal_exploded_edge_filtered() {
+            self.clone().iter().next().is_none()
+        } else {
+            self.time_index.is_empty()
+        }
+    }
 }
 
 #[derive(Clone)]
-pub struct InvertedFilteredEdgeTimeIndex<'graph, G> {
+pub struct InvertedFilteredEdgeTimeIndex<'graph, G, TS> {
     eid: ELID,
-    time_index: TimeIndexRef<'graph>,
+    time_index: TS,
     view: G,
+    _marker: PhantomData<&'graph ()>,
 }
 
-impl<'a, 'graph: 'a, G: GraphViewOps<'graph>> TimeIndexOps<'a>
-    for InvertedFilteredEdgeTimeIndex<'graph, G>
+impl<'a, G: GraphView + 'a, TS: TimeIndexOps<'a, IndexType = EventTime, RangeType = TS>>
+    TimeIndexOps<'a> for InvertedFilteredEdgeTimeIndex<'a, G, TS>
 {
     type IndexType = EventTime;
     type RangeType = Self;
@@ -141,6 +152,7 @@ impl<'a, 'graph: 'a, G: GraphViewOps<'graph>> TimeIndexOps<'a>
             eid: self.eid,
             time_index: self.time_index.range(w),
             view: self.view.clone(),
+            _marker: Default::default(),
         }
     }
 
@@ -174,7 +186,7 @@ impl<'a, 'graph: 'a, G: GraphViewOps<'graph>> TimeIndexOps<'a>
 
     fn len(&self) -> usize {
         if self.view.internal_exploded_edge_filtered() {
-            self.iter().count()
+            self.clone().iter().count()
         } else {
             0
         }
@@ -191,22 +203,25 @@ pub struct FilteredEdgeTProp<G, P> {
 impl<'graph, G: GraphViewOps<'graph>, P: TPropOps<'graph>> TPropOps<'graph>
     for FilteredEdgeTProp<G, P>
 {
-    fn iter(self) -> impl DoubleEndedIterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
+    fn iter_inner(
+        self,
+        range: Option<Range<EventTime>>,
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
         let view = self.view.clone();
         let eid = self.eid;
         self.props
-            .iter()
+            .iter_inner(range)
             .filter(move |(t, _)| view.internal_filter_exploded_edge(eid, *t, view.layer_ids()))
     }
 
-    fn iter_window(
+    fn iter_inner_rev(
         self,
-        r: Range<EventTime>,
-    ) -> impl DoubleEndedIterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
+        range: Option<Range<EventTime>>,
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
         let view = self.view.clone();
         let eid = self.eid;
         self.props
-            .iter_window(r)
+            .iter_inner_rev(range)
             .filter(move |(t, _)| view.internal_filter_exploded_edge(eid, *t, view.layer_ids()))
     }
 
@@ -227,47 +242,47 @@ pub trait FilteredEdgeStorageOps<'a> {
         self,
         view: G,
         layer_ids: &'a LayerIds,
-    ) -> impl Iterator<Item = usize> + 'a;
+    ) -> impl Iterator<Item = LayerId> + 'a;
 
     fn filtered_additions_iter<G: GraphView + 'a>(
         self,
         view: G,
         layer_ids: &'a LayerIds,
-    ) -> impl Iterator<Item = (usize, FilteredEdgeTimeIndex<'a, G>)>;
+    ) -> impl Iterator<Item = (LayerId, FilteredEdgeTimeIndex<'a, G, EdgeAdditions<'a>>)>;
 
-    fn filtered_deletions_iter<G: GraphViewOps<'a>>(
+    fn filtered_deletions_iter<G: GraphView + 'a>(
         self,
         view: G,
         layer_ids: &'a LayerIds,
-    ) -> impl Iterator<Item = (usize, FilteredEdgeTimeIndex<'a, G>)>;
+    ) -> impl Iterator<Item = (LayerId, FilteredEdgeTimeIndex<'a, G, EdgeDeletions<'a>>)>;
 
-    fn filtered_updates_iter<G: GraphViewOps<'a>>(
+    fn filtered_updates_iter<G: GraphView + 'a>(
         self,
         view: G,
         layer_ids: &'a LayerIds,
     ) -> impl Iterator<
         Item = (
-            usize,
-            FilteredEdgeTimeIndex<'a, G>,
-            FilteredEdgeTimeIndex<'a, G>,
+            LayerId,
+            FilteredEdgeTimeIndex<'a, G, EdgeAdditions<'a>>,
+            FilteredEdgeTimeIndex<'a, G, EdgeDeletions<'a>>,
         ),
     > + 'a;
 
-    fn filtered_additions<G: GraphViewOps<'a>>(
+    fn filtered_additions<G: GraphView + 'a>(
         self,
-        layer_id: usize,
+        layer_id: LayerId,
         view: G,
-    ) -> FilteredEdgeTimeIndex<'a, G>;
+    ) -> FilteredEdgeTimeIndex<'a, G, EdgeAdditions<'a>>;
 
-    fn filtered_deletions<G: GraphViewOps<'a>>(
+    fn filtered_deletions<G: GraphView + 'a>(
         self,
-        layer_id: usize,
+        layer_id: LayerId,
         view: G,
-    ) -> FilteredEdgeTimeIndex<'a, G>;
+    ) -> FilteredEdgeTimeIndex<'a, G, EdgeDeletions<'a>>;
 
-    fn filtered_temporal_prop_layer<G: GraphViewOps<'a>>(
+    fn filtered_temporal_prop_layer<G: GraphView + 'a>(
         self,
-        layer_id: usize,
+        layer_id: LayerId,
         prop_id: usize,
         view: G,
     ) -> impl TPropOps<'a> + Sync + 'a;
@@ -277,31 +292,32 @@ pub trait FilteredEdgeStorageOps<'a> {
         prop_id: usize,
         view: G,
         layer_ids: &'a LayerIds,
-    ) -> impl Iterator<Item = (usize, impl TPropOps<'a>)> + 'a;
+    ) -> impl Iterator<Item = (LayerId, impl TPropOps<'a>)> + 'a;
 
-    fn filtered_edge_metadata<'graph, G: GraphView + 'graph>(
+    fn filtered_edge_metadata<G: GraphView>(
         &self,
         view: G,
         prop_id: usize,
-        layer_filter: impl Fn(usize) -> bool,
+        layer_filter: impl Fn(LayerId) -> bool,
     ) -> Option<Prop>;
 }
 
-impl<'a> FilteredEdgeStorageOps<'a> for EdgeStorageRef<'a> {
+impl<'a> FilteredEdgeStorageOps<'a> for EdgeEntryRef<'a> {
     fn filtered_layer_ids_iter<G: GraphView + 'a>(
         self,
         view: G,
         layer_ids: &'a LayerIds,
-    ) -> impl Iterator<Item = usize> + 'a {
+    ) -> impl Iterator<Item = LayerId> + 'a {
         self.layer_ids_iter(layer_ids)
             .filter(move |layer_id| view.internal_filter_edge_layer(self, *layer_id))
+            .map(|layer_id| layer_id)
     }
 
     fn filtered_additions_iter<G: GraphView + 'a>(
         self,
         view: G,
         layer_ids: &'a LayerIds,
-    ) -> impl Iterator<Item = (usize, FilteredEdgeTimeIndex<'a, G>)> {
+    ) -> impl Iterator<Item = (LayerId, FilteredEdgeTimeIndex<'a, G, EdgeAdditions<'a>>)> {
         self.filtered_layer_ids_iter(view.clone(), layer_ids)
             .map(move |layer_id| (layer_id, self.filtered_additions(layer_id, view.clone())))
     }
@@ -310,9 +326,9 @@ impl<'a> FilteredEdgeStorageOps<'a> for EdgeStorageRef<'a> {
         self,
         view: G,
         layer_ids: &'a LayerIds,
-    ) -> impl Iterator<Item = (usize, FilteredEdgeTimeIndex<'a, G>)> {
+    ) -> impl Iterator<Item = (LayerId, FilteredEdgeTimeIndex<'a, G, EdgeDeletions<'a>>)> {
         self.filtered_layer_ids_iter(view.clone(), layer_ids)
-            .map(move |layer| (layer, self.filtered_deletions(layer, view.clone())))
+            .map(move |layer_id| (layer_id, self.filtered_deletions(layer_id, view.clone())))
     }
 
     fn filtered_updates_iter<G: GraphViewOps<'a>>(
@@ -321,9 +337,9 @@ impl<'a> FilteredEdgeStorageOps<'a> for EdgeStorageRef<'a> {
         layer_ids: &'a LayerIds,
     ) -> impl Iterator<
         Item = (
-            usize,
-            FilteredEdgeTimeIndex<'a, G>,
-            FilteredEdgeTimeIndex<'a, G>,
+            LayerId,
+            FilteredEdgeTimeIndex<'a, G, EdgeAdditions<'a>>,
+            FilteredEdgeTimeIndex<'a, G, EdgeDeletions<'a>>,
         ),
     > + 'a {
         self.filtered_layer_ids_iter(view.clone(), layer_ids)
@@ -338,31 +354,33 @@ impl<'a> FilteredEdgeStorageOps<'a> for EdgeStorageRef<'a> {
 
     fn filtered_additions<G: GraphViewOps<'a>>(
         self,
-        layer_id: usize,
+        layer_id: LayerId,
         view: G,
-    ) -> FilteredEdgeTimeIndex<'a, G> {
+    ) -> FilteredEdgeTimeIndex<'a, G, EdgeAdditions<'a>> {
         FilteredEdgeTimeIndex {
             eid: self.eid().with_layer(layer_id),
             time_index: self.additions(layer_id),
             view,
+            _marker: PhantomData,
         }
     }
 
     fn filtered_deletions<G: GraphViewOps<'a>>(
         self,
-        layer_id: usize,
+        layer_id: LayerId,
         view: G,
-    ) -> FilteredEdgeTimeIndex<'a, G> {
+    ) -> FilteredEdgeTimeIndex<'a, G, storage::EdgeDeletions<'a>> {
         FilteredEdgeTimeIndex {
             eid: self.eid().with_layer_deletion(layer_id),
             time_index: self.deletions(layer_id),
             view,
+            _marker: PhantomData,
         }
     }
 
     fn filtered_temporal_prop_layer<G: GraphViewOps<'a>>(
         self,
-        layer_id: usize,
+        layer_id: LayerId,
         prop_id: usize,
         view: G,
     ) -> impl TPropOps<'a> + Sync + 'a {
@@ -378,7 +396,7 @@ impl<'a> FilteredEdgeStorageOps<'a> for EdgeStorageRef<'a> {
         prop_id: usize,
         view: G,
         layer_ids: &'a LayerIds,
-    ) -> impl Iterator<Item = (usize, impl TPropOps<'a>)> + 'a {
+    ) -> impl Iterator<Item = (LayerId, impl TPropOps<'a>)> + 'a {
         self.filtered_layer_ids_iter(view.clone(), layer_ids)
             .map(move |layer_id| {
                 (
@@ -388,11 +406,11 @@ impl<'a> FilteredEdgeStorageOps<'a> for EdgeStorageRef<'a> {
             })
     }
 
-    fn filtered_edge_metadata<'graph, G: GraphView + 'graph>(
+    fn filtered_edge_metadata<G: GraphView>(
         &self,
         view: G,
         prop_id: usize,
-        layer_filter: impl Fn(usize) -> bool,
+        layer_filter: impl Fn(LayerId) -> bool,
     ) -> Option<Prop> {
         let layer_ids = view.layer_ids();
         let mut values = self
@@ -418,7 +436,7 @@ pub trait FilteredEdgesStorageOps {
         &'a self,
         view: G,
         layer_ids: &'a LayerIds,
-    ) -> impl ParallelIterator<Item = EdgeStorageRef<'a>> + 'a;
+    ) -> impl ParallelIterator<Item = EdgeEntryRef<'a>> + 'a;
 }
 
 impl FilteredEdgesStorageOps for EdgesStorage {
@@ -426,7 +444,7 @@ impl FilteredEdgesStorageOps for EdgesStorage {
         &'a self,
         view: G,
         layer_ids: &'a LayerIds,
-    ) -> impl ParallelIterator<Item = EdgeStorageRef<'a>> + 'a {
+    ) -> impl ParallelIterator<Item = EdgeEntryRef<'a>> + 'a {
         let par_iter = self.par_iter(layer_ids);
         match view.filter_state() {
             FilterState::Neither => FilterVariants::Neither(par_iter),
diff --git a/raphtory/src/db/api/view/internal/time_semantics/filtered_node.rs b/raphtory/src/db/api/view/internal/time_semantics/filtered_node.rs
index f998e9e367..2d0d753f84 100644
--- a/raphtory/src/db/api/view/internal/time_semantics/filtered_node.rs
+++ b/raphtory/src/db/api/view/internal/time_semantics/filtered_node.rs
@@ -7,39 +7,40 @@ use crate::{
 use either::Either;
 use itertools::Itertools;
 use raphtory_api::core::{
-    entities::{edges::edge_ref::EdgeRef, LayerIds, ELID, VID},
+    entities::{
+        edges::edge_ref::EdgeRef, layers::Multiple, properties::meta::STATIC_GRAPH_LAYER_ID,
+        LayerIds, ELID, VID,
+    },
     storage::timeindex::{EventTime, TimeIndexOps},
     Direction,
 };
-use raphtory_core::storage::timeindex::TimeIndexWindow;
-use raphtory_storage::{
-    core_ops::CoreGraphOps,
-    graph::nodes::{node_additions::NodeAdditions, node_storage_ops::NodeStorageOps},
-};
-use std::ops::Range;
+use raphtory_storage::{core_ops::CoreGraphOps, graph::nodes::node_storage_ops::NodeStorageOps};
+use std::{ops::Range, sync::Arc};
+use storage::gen_ts::LayerIter;
 
 #[derive(Debug, Clone)]
 pub struct NodeHistory<'a, G> {
-    pub(crate) additions: NodeAdditions<'a>,
+    pub(crate) edge_history: storage::NodeEdgeAdditions<'a>,
+    pub(crate) additions: storage::NodePropAdditions<'a>,
     pub(crate) view: G,
 }
 
 #[derive(Debug, Clone)]
 pub struct NodeEdgeHistory<'a, G> {
-    pub(crate) additions: NodeAdditions<'a>,
+    pub(crate) additions: storage::NodeEdgeAdditions<'a>,
     pub(crate) view: G,
 }
 
 #[derive(Debug, Clone)]
 pub struct NodePropHistory<'a, G> {
-    pub(crate) additions: NodeAdditions<'a>,
+    pub(crate) additions: storage::NodePropAdditions<'a>,
     pub(crate) view: G,
 }
 
 impl<'a, G: Clone> NodeHistory<'a, G> {
     pub fn edge_history(&self) -> NodeEdgeHistory<'a, G> {
         NodeEdgeHistory {
-            additions: self.additions.clone(),
+            additions: self.edge_history.clone(),
             view: self.view.clone(),
         }
     }
@@ -68,11 +69,11 @@ fn handle_update_iter<'graph, G: GraphViewOps<'graph>>(
 
 impl<'a, G: GraphViewOps<'a>> NodeEdgeHistory<'a, G> {
     pub fn history(&self) -> impl Iterator<Item = (EventTime, ELID)> + use<'a, G> {
-        handle_update_iter(self.additions.edge_events(), self.view.clone())
+        handle_update_iter(self.additions.clone().edge_events(), self.view.clone())
     }
 
     pub fn history_rev(&self) -> impl Iterator<Item = (EventTime, ELID)> + use<'a, G> {
-        handle_update_iter(self.additions.edge_events_rev(), self.view.clone())
+        handle_update_iter(self.additions.clone().edge_events_rev(), self.view.clone())
     }
 }
 
@@ -81,21 +82,7 @@ impl<'a, G: GraphViewOps<'a>> TimeIndexOps<'a> for NodePropHistory<'a, G> {
     type RangeType = Self;
 
     fn active(&self, w: Range<Self::IndexType>) -> bool {
-        let history = &self.additions;
-        match history {
-            NodeAdditions::Mem(h) => h.props_ts().active(w),
-            NodeAdditions::Range(h) => match h {
-                TimeIndexWindow::Empty => false,
-                TimeIndexWindow::Range { timeindex, range } => {
-                    let start = range.start.max(w.start);
-                    let end = range.end.min(w.end).max(start);
-                    timeindex.props_ts().active(start..end)
-                }
-                TimeIndexWindow::All(h) => h.props_ts().active(w),
-            },
-            #[cfg(feature = "storage")]
-            NodeAdditions::Col(h) => h.with_range(w).prop_events().any(|t| !t.is_empty()),
-        }
+        self.additions.active(w)
     }
 
     fn range(&self, w: Range<Self::IndexType>) -> Self::RangeType {
@@ -107,41 +94,19 @@ impl<'a, G: GraphViewOps<'a>> TimeIndexOps<'a> for NodePropHistory<'a, G> {
     }
 
     fn iter(self) -> impl Iterator<Item = Self::IndexType> + Send + Sync + 'a {
-        self.additions.prop_events()
+        self.additions.iter()
     }
 
     fn iter_rev(self) -> impl Iterator<Item = Self::IndexType> + Send + Sync + 'a {
-        self.additions.prop_events_rev()
+        self.additions.iter_rev()
     }
 
     fn len(&self) -> usize {
-        match &self.additions {
-            NodeAdditions::Mem(additions) => additions.props_ts.len(),
-            NodeAdditions::Range(additions) => match additions {
-                TimeIndexWindow::Empty => 0,
-                TimeIndexWindow::Range { timeindex, range } => {
-                    (&timeindex.props_ts).range(range.clone()).len()
-                }
-                TimeIndexWindow::All(timeindex) => timeindex.props_ts.len(),
-            },
-            #[cfg(feature = "storage")]
-            NodeAdditions::Col(additions) => additions.clone().prop_events().map(|t| t.len()).sum(),
-        }
+        self.additions.len()
     }
 
     fn is_empty(&self) -> bool {
-        match &self.additions {
-            NodeAdditions::Mem(additions) => additions.props_ts.is_empty(),
-            NodeAdditions::Range(additions) => match additions {
-                TimeIndexWindow::Empty => true,
-                TimeIndexWindow::Range { timeindex, range } => {
-                    (&timeindex.props_ts).range(range.clone()).is_empty()
-                }
-                TimeIndexWindow::All(timeindex) => timeindex.props_ts.is_empty(),
-            },
-            #[cfg(feature = "storage")]
-            NodeAdditions::Col(additions) => additions.clone().prop_events().all(|t| t.is_empty()),
-        }
+        self.additions.is_empty()
     }
 }
 
@@ -171,18 +136,7 @@ impl<'a, G: GraphViewOps<'a>> TimeIndexOps<'a> for NodeEdgeHistory<'a, G> {
 
     fn len(&self) -> usize {
         if matches!(self.view.filter_state(), FilterState::Neither) {
-            match &self.additions {
-                NodeAdditions::Mem(additions) => additions.edge_ts.len(),
-                NodeAdditions::Range(additions) => match additions {
-                    TimeIndexWindow::Empty => 0,
-                    TimeIndexWindow::Range { timeindex, range } => {
-                        (&timeindex.edge_ts).range(range.clone()).len()
-                    }
-                    TimeIndexWindow::All(timeindex) => timeindex.edge_ts.len(),
-                },
-                #[cfg(feature = "storage")]
-                NodeAdditions::Col(additions) => additions.edge_history().count(),
-            }
+            self.additions.len()
         } else {
             self.history().count()
         }
@@ -190,20 +144,7 @@ impl<'a, G: GraphViewOps<'a>> TimeIndexOps<'a> for NodeEdgeHistory<'a, G> {
 
     fn is_empty(&self) -> bool {
         if matches!(self.view.filter_state(), FilterState::Neither) {
-            match &self.additions {
-                NodeAdditions::Mem(additions) => additions.edge_ts.is_empty(),
-                NodeAdditions::Range(additions) => match additions {
-                    TimeIndexWindow::Empty => true,
-                    TimeIndexWindow::Range { timeindex, range } => {
-                        (&timeindex.edge_ts).range(range.clone()).is_empty()
-                    }
-                    TimeIndexWindow::All(timeindex) => timeindex.edge_ts.is_empty(),
-                },
-                #[cfg(feature = "storage")]
-                NodeAdditions::Col(additions) => {
-                    additions.clone().edge_events().all(|t| t.is_empty())
-                }
-            }
+            self.additions.is_empty()
         } else {
             self.history().next().is_none()
         }
@@ -219,9 +160,14 @@ impl<'b, G: GraphViewOps<'b>> TimeIndexOps<'b> for NodeHistory<'b, G> {
     }
 
     fn range(&self, w: Range<Self::IndexType>) -> Self {
+        let edge_history = self.edge_history.range(w.clone());
         let additions = self.additions.range(w);
         let view = self.view.clone();
-        NodeHistory { additions, view }
+        NodeHistory {
+            edge_history,
+            additions,
+            view,
+        }
     }
 
     fn iter(self) -> impl Iterator<Item = Self::IndexType> + Send + Sync + 'b {
@@ -243,17 +189,62 @@ impl<'b, G: GraphViewOps<'b>> TimeIndexOps<'b> for NodeHistory<'b, G> {
     }
 }
 
+/// Build a `LayerIter` that includes `STATIC_GRAPH_LAYER_ID` in addition to any explicitly
+/// requested layers. Nodes added without a specific layer are stored in STATIC_GRAPH_LAYER_ID
+/// and should be visible in every layer-restricted view.
+fn layer_ids_with_static(layer_ids: &LayerIds) -> LayerIter<'_> {
+    match layer_ids {
+        // All layers already includes STATIC
+        LayerIds::All => LayerIter::LRef(layer_ids),
+        // No layers + static = just static
+        LayerIds::None => LayerIter::One(STATIC_GRAPH_LAYER_ID),
+        LayerIds::One(id) => {
+            if *id == STATIC_GRAPH_LAYER_ID {
+                LayerIter::One(*id)
+            } else {
+                // Return both the static layer and the requested layer, sorted for binary search
+                let mut ids = [STATIC_GRAPH_LAYER_ID, *id];
+                ids.sort();
+                LayerIter::Multiple(Multiple(Arc::from(ids.as_slice())))
+            }
+        }
+        LayerIds::Multiple(ids) => {
+            if ids.contains(STATIC_GRAPH_LAYER_ID) {
+                LayerIter::LRef(layer_ids)
+            } else {
+                let mut combined: Vec<_> = std::iter::once(STATIC_GRAPH_LAYER_ID)
+                    .chain(ids.iter())
+                    .collect();
+                combined.sort();
+                LayerIter::Multiple(Multiple(Arc::from(combined.as_slice())))
+            }
+        }
+    }
+}
+
 pub trait FilteredNodeStorageOps<'a>: NodeStorageOps<'a> {
     /// Get a filtered view of the update history of the node
     ///
     /// Note that this is an internal API that does not apply the window filtering!
-    fn history<G: GraphView + 'a>(self, view: G) -> NodeHistory<'a, G> {
-        let additions = self.additions();
-        NodeHistory { additions, view }
+    fn history<G: GraphView + 'a>(self, view: G, layer_ids: &'a LayerIds) -> NodeHistory<'a, G> {
+        // Nodes added without a specific layer go to STATIC_GRAPH_LAYER_ID and should appear
+        // active in any layer-restricted view. Nodes added with an explicit layer only appear
+        // in that layer's view.
+        let additions = self.node_additions(layer_ids_with_static(layer_ids));
+        let edge_history = self.node_edge_additions(layer_ids);
+        NodeHistory {
+            edge_history,
+            additions,
+            view,
+        }
     }
 
-    fn edge_history<G: GraphView + 'a>(self, view: G) -> NodeEdgeHistory<'a, G> {
-        self.history(view).edge_history()
+    fn edge_history<G: GraphView + 'a>(
+        self,
+        view: G,
+        layer_ids: &'a LayerIds,
+    ) -> NodeEdgeHistory<'a, G> {
+        self.history(view, layer_ids).edge_history()
     }
 
     fn filtered_edges_iter<G: GraphViewOps<'a>>(
diff --git a/raphtory/src/db/api/view/internal/time_semantics/mod.rs b/raphtory/src/db/api/view/internal/time_semantics/mod.rs
index a27e7aab5a..6e88b05dcd 100644
--- a/raphtory/src/db/api/view/internal/time_semantics/mod.rs
+++ b/raphtory/src/db/api/view/internal/time_semantics/mod.rs
@@ -1,7 +1,7 @@
-use crate::db::api::view::BoxedLDIter;
 use raphtory_api::{
     core::{entities::properties::prop::Prop, storage::timeindex::EventTime},
     inherit::Base,
+    iter::BoxedLIter,
 };
 use std::ops::Range;
 
@@ -59,7 +59,7 @@ pub trait GraphTimeSemanticsOps {
     /// A vector of tuples representing the temporal values of the property
     /// that fall within the specified time window, where the first element of each tuple is the timestamp
     /// and the second element is the property value.
-    fn temporal_prop_iter(&self, prop_id: usize) -> BoxedLDIter<'_, (EventTime, Prop)>;
+    fn temporal_prop_iter(&self, prop_id: usize) -> BoxedLIter<'_, (EventTime, Prop)>;
     /// Check if graph has temporal property with the given id in the window
     ///
     /// # Arguments
@@ -87,7 +87,28 @@ pub trait GraphTimeSemanticsOps {
         prop_id: usize,
         start: EventTime,
         end: EventTime,
-    ) -> BoxedLDIter<'_, (EventTime, Prop)>;
+    ) -> BoxedLIter<'_, (EventTime, Prop)>;
+
+    /// Returns all temporal values of the graph property with the given name
+    /// that fall within the specified time window in reverse order.
+    ///
+    /// # Arguments
+    ///
+    /// * `name` - The name of the property to retrieve.
+    /// * `start` - The start time of the window to consider.
+    /// * `end` - The end time of the window to consider.
+    ///
+    /// Returns:
+    ///
+    /// Iterator of tuples representing the temporal values of the property in reverse order
+    /// that fall within the specified time window, where the first element of each tuple is the timestamp
+    /// and the second element is the property value.
+    fn temporal_prop_iter_window_rev(
+        &self,
+        prop_id: usize,
+        start: EventTime,
+        end: EventTime,
+    ) -> BoxedLIter<'_, (EventTime, Prop)>;
 
     /// Returns the value and update time for the temporal graph property at or before a given timestamp
     fn temporal_prop_last_at(&self, prop_id: usize, t: EventTime) -> Option<(EventTime, Prop)>;
@@ -161,7 +182,7 @@ impl<G: DelegateTimeSemantics + ?Sized> GraphTimeSemanticsOps for G {
     }
 
     #[inline]
-    fn temporal_prop_iter(&self, prop_id: usize) -> BoxedLDIter<'_, (EventTime, Prop)> {
+    fn temporal_prop_iter(&self, prop_id: usize) -> BoxedLIter<'_, (EventTime, Prop)> {
         self.graph().temporal_prop_iter(prop_id)
     }
 
@@ -176,10 +197,21 @@ impl<G: DelegateTimeSemantics + ?Sized> GraphTimeSemanticsOps for G {
         prop_id: usize,
         start: EventTime,
         end: EventTime,
-    ) -> BoxedLDIter<'_, (EventTime, Prop)> {
+    ) -> BoxedLIter<'_, (EventTime, Prop)> {
         self.graph().temporal_prop_iter_window(prop_id, start, end)
     }
 
+    #[inline]
+    fn temporal_prop_iter_window_rev(
+        &self,
+        prop_id: usize,
+        start: EventTime,
+        end: EventTime,
+    ) -> BoxedLIter<'_, (EventTime, Prop)> {
+        self.graph()
+            .temporal_prop_iter_window_rev(prop_id, start, end)
+    }
+
     #[inline]
     fn temporal_prop_last_at(&self, prop_id: usize, t: EventTime) -> Option<(EventTime, Prop)> {
         self.graph().temporal_prop_last_at(prop_id, t)
diff --git a/raphtory/src/db/api/view/internal/time_semantics/persistent_semantics.rs b/raphtory/src/db/api/view/internal/time_semantics/persistent_semantics.rs
index c234faf122..c28e6aa961 100644
--- a/raphtory/src/db/api/view/internal/time_semantics/persistent_semantics.rs
+++ b/raphtory/src/db/api/view/internal/time_semantics/persistent_semantics.rs
@@ -15,28 +15,39 @@ use either::Either;
 use itertools::Itertools;
 use raphtory_api::core::{
     entities::{
-        properties::{prop::Prop, tprop::TPropOps},
-        LayerIds, ELID,
+        properties::{meta::STATIC_GRAPH_LAYER_ID, prop::Prop, tprop::TPropOps},
+        LayerId, LayerIds, ELID,
     },
     storage::timeindex::{AsTime, EventTime, MergedTimeIndex, TimeIndexOps},
 };
 use raphtory_storage::graph::{
-    edges::{edge_ref::EdgeStorageRef, edge_storage_ops::EdgeStorageOps},
+    edges::edge_storage_ops::EdgeStorageOps,
     nodes::{node_ref::NodeStorageRef, node_storage_ops::NodeStorageOps},
 };
 use std::{iter, ops::Range};
-
-fn alive_before<'a, G: GraphViewOps<'a>>(
-    additions: FilteredEdgeTimeIndex<'a, G>,
-    deletions: FilteredEdgeTimeIndex<'a, G>,
+use storage::{EdgeAdditions, EdgeDeletions, EdgeEntryRef};
+
+fn alive_before<
+    'a,
+    G: GraphViewOps<'a>,
+    TSA: TimeIndexOps<'a, IndexType = EventTime, RangeType = TSA>,
+    TSD: TimeIndexOps<'a, IndexType = EventTime, RangeType = TSD>,
+>(
+    additions: FilteredEdgeTimeIndex<'a, G, TSA>,
+    deletions: FilteredEdgeTimeIndex<'a, G, TSD>,
     t: EventTime,
 ) -> bool {
     last_before(additions, deletions, t).is_some()
 }
 
-fn last_before<'a, G: GraphViewOps<'a>>(
-    additions: FilteredEdgeTimeIndex<'a, G>,
-    deletions: FilteredEdgeTimeIndex<'a, G>,
+fn last_before<
+    'a,
+    G: GraphViewOps<'a>,
+    TSA: TimeIndexOps<'a, IndexType = EventTime, RangeType = TSA>,
+    TSD: TimeIndexOps<'a, IndexType = EventTime, RangeType = TSD>,
+>(
+    additions: FilteredEdgeTimeIndex<'a, G, TSA>,
+    deletions: FilteredEdgeTimeIndex<'a, G, TSD>,
     t: EventTime,
 ) -> Option<EventTime> {
     let last_addition_before_start = additions.range(EventTime::MIN..t).last();
@@ -51,9 +62,14 @@ fn last_before<'a, G: GraphViewOps<'a>>(
     }
 }
 
-fn persisted_event<'a, G: GraphViewOps<'a>>(
-    additions: FilteredEdgeTimeIndex<'a, G>,
-    deletions: FilteredEdgeTimeIndex<'a, G>,
+fn persisted_event<
+    'a,
+    G: GraphViewOps<'a>,
+    TSA: TimeIndexOps<'a, IndexType = EventTime, RangeType = TSA>,
+    TSD: TimeIndexOps<'a, IndexType = EventTime, RangeType = TSD>,
+>(
+    additions: FilteredEdgeTimeIndex<'a, G, TSA>,
+    deletions: FilteredEdgeTimeIndex<'a, G, TSD>,
     t: EventTime,
 ) -> Option<EventTime> {
     let active_at_start = deletions.active(t..EventTime::start(t.t().saturating_add(1)))
@@ -68,7 +84,7 @@ fn persisted_event<'a, G: GraphViewOps<'a>>(
 }
 
 fn edge_alive_at_end<'graph, G: GraphViewOps<'graph>>(
-    e: EdgeStorageRef<'graph>,
+    e: EdgeEntryRef<'graph>,
     t: EventTime,
     view: G,
 ) -> bool {
@@ -77,7 +93,7 @@ fn edge_alive_at_end<'graph, G: GraphViewOps<'graph>>(
 }
 
 fn edge_alive_at_start<'graph, G: GraphViewOps<'graph>>(
-    e: EdgeStorageRef<'graph>,
+    e: EdgeEntryRef<'graph>,
     t: EventTime,
     view: G,
 ) -> bool {
@@ -113,11 +129,14 @@ fn node_has_valid_edges<'graph, G: GraphView>(
         })
 }
 
-fn merged_deletions<'graph, G: GraphViewOps<'graph>>(
-    e: EdgeStorageRef<'graph>,
+fn merged_deletions<'a, G: GraphView + 'a>(
+    e: EdgeEntryRef<'a>,
     view: G,
-    layer: usize,
-) -> MergedTimeIndex<FilteredEdgeTimeIndex<'graph, G>, InvertedFilteredEdgeTimeIndex<'graph, G>> {
+    layer: LayerId,
+) -> MergedTimeIndex<
+    FilteredEdgeTimeIndex<'a, G, EdgeDeletions<'a>>,
+    InvertedFilteredEdgeTimeIndex<'a, G, EdgeAdditions<'a>>,
+> {
     e.filtered_deletions(layer, view.clone())
         .merge(e.filtered_additions(layer, view).invert())
 }
@@ -140,6 +159,7 @@ fn last_prop_value_before<'a, 'b>(
 fn persisted_prop_value_at<'a, 'b>(
     t: EventTime,
     props: impl TPropOps<'a>,
+    additions: impl TimeIndexOps<'b, IndexType = EventTime>,
     deletions: impl TimeIndexOps<'b, IndexType = EventTime>,
 ) -> Option<(EventTime, Prop)> {
     if props.active(t..EventTime::start(t.t().saturating_add(1)))
@@ -147,10 +167,23 @@ fn persisted_prop_value_at<'a, 'b>(
     {
         None
     } else {
-        last_prop_value_before(t, props, deletions)
+        persisted_secondary_index(t, additions).and_then(|index| {
+            last_prop_value_before(t, props, deletions).map(|(_, v)| (t.set_event_id(index), v))
+        })
     }
 }
 
+fn persisted_secondary_index<'a>(
+    t: EventTime,
+    additions: impl TimeIndexOps<'a, IndexType = EventTime>,
+) -> Option<usize> {
+    additions
+        .range(t..EventTime::start(t.t().saturating_add(1)))
+        .first()
+        .or_else(|| additions.range(EventTime::MIN..t).last())
+        .map(|t| t.i())
+}
+
 /// Exclude anything from the window that happens before the last deletion at the start of the window
 fn interior_window<'a>(
     w: Range<EventTime>,
@@ -173,7 +206,7 @@ impl NodeTimeSemanticsOps for PersistentSemantics {
         node: NodeStorageRef<'graph>,
         view: G,
     ) -> Option<EventTime> {
-        node.history(view).first()
+        node.history(&view, view.layer_ids()).first()
     }
 
     fn node_latest_time<'graph, G: GraphViewOps<'graph>>(
@@ -181,7 +214,7 @@ impl NodeTimeSemanticsOps for PersistentSemantics {
         node: NodeStorageRef<'graph>,
         view: G,
     ) -> Option<EventTime> {
-        node.history(view).last()
+        node.history(&view, view.layer_ids()).last()
     }
 
     fn node_earliest_time_window<'graph, G: GraphViewOps<'graph>>(
@@ -190,7 +223,7 @@ impl NodeTimeSemanticsOps for PersistentSemantics {
         view: G,
         w: Range<EventTime>,
     ) -> Option<EventTime> {
-        let history = node.history(&view);
+        let history = node.history(&view, view.layer_ids());
         let prop_earliest = history.prop_history().range(EventTime::MIN..w.end).first();
 
         if let Some(prop_earliest) = prop_earliest {
@@ -216,7 +249,7 @@ impl NodeTimeSemanticsOps for PersistentSemantics {
         view: G,
         w: Range<EventTime>,
     ) -> Option<EventTime> {
-        let history = node.history(&view);
+        let history = node.history(&view, view.layer_ids());
         history
             .range(EventTime::start(w.start.t().saturating_add(1))..w.end)
             .last()
@@ -233,34 +266,38 @@ impl NodeTimeSemanticsOps for PersistentSemantics {
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
     ) -> impl Iterator<Item = EventTime> + Send + Sync + 'graph {
-        node.history(view).iter()
+        node.history(view, layer_ids).iter()
     }
 
     fn node_history_rev<'graph, G: GraphViewOps<'graph>>(
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
     ) -> impl Iterator<Item = EventTime> + Send + Sync + 'graph {
-        node.history(view).iter_rev()
+        node.history(view, layer_ids).iter_rev()
     }
 
     fn node_history_window<'graph, G: GraphViewOps<'graph>>(
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
     ) -> impl Iterator<Item = EventTime> + Send + Sync + 'graph {
-        node.history(view).range(w).iter()
+        node.history(view, layer_ids).range(w).iter()
     }
 
     fn node_history_window_rev<'graph, G: GraphViewOps<'graph>>(
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
     ) -> impl Iterator<Item = EventTime> + Send + Sync + 'graph {
-        node.history(view).range(w).iter_rev()
+        node.history(view, layer_ids).range(w).iter_rev()
     }
 
     fn node_edge_history_count<'graph, G: GraphView + 'graph>(
@@ -284,65 +321,68 @@ impl NodeTimeSemanticsOps for PersistentSemantics {
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
     ) -> impl Iterator<Item = (EventTime, ELID)> + Send + Sync + 'graph {
-        EventSemantics.node_edge_history(node, view)
+        EventSemantics.node_edge_history(node, view, layer_ids)
     }
 
     fn node_edge_history_window<'graph, G: GraphView + 'graph>(
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
     ) -> impl Iterator<Item = (EventTime, ELID)> + Send + Sync + 'graph {
-        EventSemantics.node_edge_history_window(node, view, w)
+        EventSemantics.node_edge_history_window(node, view, layer_ids, w)
     }
 
     fn node_edge_history_rev<'graph, G: GraphView + 'graph>(
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
     ) -> impl Iterator<Item = (EventTime, ELID)> + Send + Sync + 'graph {
-        EventSemantics.node_edge_history_rev(node, view)
+        EventSemantics.node_edge_history_rev(node, view, layer_ids)
     }
 
     fn node_edge_history_rev_window<'graph, G: GraphView + 'graph>(
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
     ) -> impl Iterator<Item = (EventTime, ELID)> + Send + Sync + 'graph {
-        EventSemantics.node_edge_history_rev_window(node, view, w)
+        EventSemantics.node_edge_history_rev_window(node, view, layer_ids, w)
     }
 
     fn node_updates<'graph, G: GraphViewOps<'graph>>(
         self,
         node: NodeStorageRef<'graph>,
         _view: G,
-    ) -> impl Iterator<Item = (EventTime, Vec<(usize, Prop)>)> + Send + Sync + 'graph {
-        node.temp_prop_rows().map(|(t, row)| {
-            (
-                t,
-                row.into_iter().filter_map(|(i, v)| Some((i, v?))).collect(),
-            )
-        })
+    ) -> impl Iterator<Item = (EventTime, LayerId, Vec<(usize, Prop)>)> + Send + Sync + 'graph {
+        node.temp_prop_rows()
+            .map(|(t, l, row)| (t, LayerId(l), row))
     }
 
     fn node_updates_window<'graph, G: GraphViewOps<'graph>>(
         self,
         node: NodeStorageRef<'graph>,
-        _view: G,
+        view: G,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, Vec<(usize, Prop)>)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId, Vec<(usize, Prop)>)> + Send + Sync + 'graph {
         let start = w.start;
         let first_row = if node
             .additions()
             .range(EventTime::MIN..start)
-            .prop_events()
+            .iter()
             .next()
             .is_some()
         {
             Some(
-                node.tprops()
+                view.node_meta()
+                    .temporal_prop_mapper()
+                    .ids()
+                    .map(|prop_id| (prop_id, node.tprop(prop_id)))
                     .filter_map(|(i, tprop)| {
                         if tprop.active(start..EventTime::start(start.t().saturating_add(1))) {
                             None
@@ -357,13 +397,11 @@ impl NodeTimeSemanticsOps for PersistentSemantics {
         };
         first_row
             .into_iter()
-            .map(move |row| (start, row))
-            .chain(node.temp_prop_rows_window(w).map(|(t, row)| {
-                (
-                    t,
-                    row.into_iter().filter_map(|(i, v)| Some((i, v?))).collect(),
-                )
-            }))
+            .map(move |row| (start, STATIC_GRAPH_LAYER_ID, row))
+            .chain(
+                node.temp_prop_rows_range(Some(w))
+                    .map(|(t, l, row)| (t, LayerId(l), row)),
+            )
     }
 
     fn node_valid<'graph, G: GraphViewOps<'graph>>(
@@ -371,7 +409,7 @@ impl NodeTimeSemanticsOps for PersistentSemantics {
         node: NodeStorageRef<'graph>,
         view: G,
     ) -> bool {
-        !node.history(view).is_empty()
+        !node.history(&view, view.layer_ids()).is_empty()
     }
 
     fn node_valid_window<'graph, G: GraphViewOps<'graph>>(
@@ -384,7 +422,7 @@ impl NodeTimeSemanticsOps for PersistentSemantics {
             // empty window
             return false;
         }
-        let history = node.history(&view);
+        let history = node.history(&view, view.layer_ids());
         history.prop_history().active(EventTime::MIN..w.end)
             || history
                 .edge_history()
@@ -395,50 +433,101 @@ impl NodeTimeSemanticsOps for PersistentSemantics {
     fn node_tprop_iter<'graph, G: GraphViewOps<'graph>>(
         &self,
         node: NodeStorageRef<'graph>,
-        _view: G,
+        view: G,
+        prop_id: usize,
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
+        node.tprop_iter_layers(view.layer_ids(), prop_id)
+            .map(|p| p.iter())
+            .kmerge_by(|(a, _), (b, _)| a <= b)
+    }
+
+    fn node_tprop_iter_rev<'graph, G: GraphView + 'graph>(
+        &self,
+        node: NodeStorageRef<'graph>,
+        view: G,
         prop_id: usize,
-    ) -> impl DoubleEndedIterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
-        node.tprop(prop_id).iter()
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
+        node.tprop_iter_layers(view.layer_ids(), prop_id)
+            .map(|p| p.iter_rev())
+            .kmerge_by(|(a, _), (b, _)| a >= b)
     }
 
     fn node_tprop_iter_window<'graph, G: GraphViewOps<'graph>>(
         &self,
         node: NodeStorageRef<'graph>,
-        _view: G,
+        view: G,
         prop_id: usize,
         w: Range<EventTime>,
-    ) -> impl DoubleEndedIterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
-        let prop = node.tprop(prop_id);
-        let first = if prop.active(w.start..EventTime::start(w.start.t().saturating_add(1))) {
-            None
-        } else {
-            prop.last_before(w.start).map(|(t, v)| (t.max(w.start), v))
-        };
-        first.into_iter().chain(prop.iter_window(w))
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
+        let tprops: Vec<_> = node.tprop_iter_layers(view.layer_ids(), prop_id).collect();
+        let first = tprops
+            .iter()
+            .copied()
+            .filter_map(|prop| {
+                if prop.active(w.start..EventTime::start(w.start.t().saturating_add(1))) {
+                    None
+                } else {
+                    prop.last_before(w.start).map(|(t, v)| (t.max(w.start), v))
+                }
+            })
+            .max_by_key(|(t, _)| *t);
+        let window_iter = tprops
+            .into_iter()
+            .map(move |prop| prop.iter_window(w.clone()))
+            .kmerge_by(|(a, _), (b, _)| a <= b);
+        first.into_iter().chain(window_iter)
+    }
+
+    fn node_tprop_iter_window_rev<'graph, G: GraphView + 'graph>(
+        &self,
+        node: NodeStorageRef<'graph>,
+        view: G,
+        prop_id: usize,
+        w: Range<EventTime>,
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
+        let tprops: Vec<_> = node.tprop_iter_layers(view.layer_ids(), prop_id).collect();
+        let first = tprops
+            .iter()
+            .copied()
+            .filter_map(|prop| {
+                if prop.active(w.start..EventTime::start(w.start.t().saturating_add(1))) {
+                    None
+                } else {
+                    prop.last_before(w.start).map(|(t, v)| (t.max(w.start), v))
+                }
+            })
+            .max_by_key(|(t, _)| *t);
+        let window_iter_rev = tprops
+            .into_iter()
+            .map(move |prop| prop.iter_window_rev(w.clone()))
+            .kmerge_by(|(a, _), (b, _)| a >= b);
+        window_iter_rev.chain(first)
     }
 
     fn node_tprop_last_at<'graph, G: GraphViewOps<'graph>>(
         &self,
         node: NodeStorageRef<'graph>,
-        _view: G,
+        view: G,
         prop_id: usize,
         t: EventTime,
     ) -> Option<(EventTime, Prop)> {
-        let prop = node.tprop(prop_id);
-        prop.last_before(t.next())
+        node.tprop_iter_layers(view.layer_ids(), prop_id)
+            .filter_map(|prop| prop.last_before(t.next()))
+            .max_by_key(|(t, _)| *t)
     }
 
     fn node_tprop_last_at_window<'graph, G: GraphViewOps<'graph>>(
         &self,
         node: NodeStorageRef<'graph>,
-        _view: G,
+        view: G,
         prop_id: usize,
         t: EventTime,
         w: Range<EventTime>,
     ) -> Option<(EventTime, Prop)> {
         if w.contains(&t) {
-            let prop = node.tprop(prop_id);
-            prop.last_before(t.next()).map(|(t, v)| (t.max(w.start), v))
+            node.tprop_iter_layers(view.layer_ids(), prop_id)
+                .filter_map(|prop| prop.last_before(t.next()).map(|(t, v)| (t.max(w.start), v)))
+                .max_by_key(|(t, _)| *t)
         } else {
             None
         }
@@ -487,9 +576,9 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
 
     fn include_edge<G: GraphView>(
         &self,
-        _edge: EdgeStorageRef,
+        _edge: EdgeEntryRef,
         _view: G,
-        _layer_id: usize,
+        _layer_id: LayerId,
     ) -> bool {
         // history filtering only maps additions to deletions and thus doesn't filter edges
         true
@@ -497,9 +586,9 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
 
     fn include_edge_window<G: GraphView>(
         &self,
-        edge: EdgeStorageRef,
+        edge: EdgeEntryRef,
         view: G,
-        layer_id: usize,
+        layer_id: LayerId,
         w: Range<EventTime>,
     ) -> bool {
         // If an edge has any event in the interior (both end exclusive) of the window it is always included.
@@ -553,29 +642,29 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
 
     fn edge_history<'graph, G: GraphViewOps<'graph>>(
         self,
-        edge: EdgeStorageRef<'graph>,
+        edge: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         EventSemantics.edge_history(edge, view, layer_ids)
     }
 
     fn edge_history_rev<'graph, G: GraphViewOps<'graph>>(
         self,
-        edge: EdgeStorageRef<'graph>,
+        edge: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         EventSemantics.edge_history_rev(edge, view, layer_ids)
     }
 
     fn edge_history_window<'graph, G: GraphViewOps<'graph>>(
         self,
-        edge: EdgeStorageRef<'graph>,
+        edge: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         edge.filtered_updates_iter(view, layer_ids)
             .map(|(layer, additions, deletions)| {
                 let window = interior_window(w.clone(), &deletions);
@@ -586,11 +675,11 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
 
     fn edge_history_window_rev<'graph, G: GraphViewOps<'graph>>(
         self,
-        edge: EdgeStorageRef<'graph>,
+        edge: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         edge.filtered_updates_iter(view, layer_ids)
             .map(|(layer, additions, deletions)| {
                 let window = interior_window(w.clone(), &deletions);
@@ -601,7 +690,7 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
 
     fn edge_exploded_count<'graph, G: GraphViewOps<'graph>>(
         &self,
-        edge: EdgeStorageRef,
+        edge: EdgeEntryRef,
         view: G,
     ) -> usize {
         EventSemantics.edge_exploded_count(edge, view)
@@ -609,7 +698,7 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
 
     fn edge_exploded_count_window<'graph, G: GraphViewOps<'graph>>(
         &self,
-        edge: EdgeStorageRef,
+        edge: EdgeEntryRef,
         view: G,
         w: Range<EventTime>,
     ) -> usize {
@@ -627,29 +716,29 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
 
     fn edge_exploded<'graph, G: GraphViewOps<'graph>>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         EventSemantics.edge_exploded(e, view, layer_ids)
     }
 
     fn edge_layers<'graph, G: GraphViewOps<'graph>>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = usize> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = LayerId> + Send + Sync + 'graph {
         e.filtered_layer_ids_iter(view, layer_ids)
     }
 
     fn edge_window_exploded<'graph, G: GraphViewOps<'graph>>(
         self,
-        edge: EdgeStorageRef<'graph>,
+        edge: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         if w.end <= w.start {
             Either::Left(iter::empty())
         } else {
@@ -670,11 +759,11 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
 
     fn edge_window_layers<'graph, G: GraphViewOps<'graph>>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = usize> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = LayerId> + Send + Sync + 'graph {
         let exclusive_start = EventTime::start(w.start.t().saturating_add(1));
         e.filtered_updates_iter(view, layer_ids)
             .filter_map(move |(layer, additions, deletions)| {
@@ -691,7 +780,7 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
 
     fn edge_earliest_time<'graph, G: GraphViewOps<'graph>>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
     ) -> Option<EventTime> {
         e.filtered_additions_iter(&view, view.layer_ids())
@@ -705,7 +794,7 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
 
     fn edge_earliest_time_window<'graph, G: GraphViewOps<'graph>>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         w: Range<EventTime>,
     ) -> Option<EventTime> {
@@ -729,20 +818,20 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
 
     fn edge_exploded_earliest_time<'graph, G: GraphViewOps<'graph>>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
     ) -> Option<EventTime> {
         EventSemantics.edge_exploded_earliest_time(e, view, t, layer)
     }
 
     fn edge_exploded_earliest_time_window<'graph, G: GraphViewOps<'graph>>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
         w: Range<EventTime>,
     ) -> Option<EventTime> {
         // past the end of the window
@@ -770,7 +859,7 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
 
     fn edge_latest_time<'graph, G: GraphViewOps<'graph>>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
     ) -> Option<EventTime> {
         e.filtered_additions_iter(&view, view.layer_ids())
@@ -784,7 +873,7 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
 
     fn edge_latest_time_window<'graph, G: GraphViewOps<'graph>>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         w: Range<EventTime>,
     ) -> Option<EventTime> {
@@ -807,10 +896,10 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
 
     fn edge_exploded_latest_time<'graph, G: GraphViewOps<'graph>>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
     ) -> Option<EventTime> {
         let deletions = e.filtered_deletions(layer, &view);
         let additions = e.additions(layer); // unfiltered as filtered additions act like deletions
@@ -825,10 +914,10 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
 
     fn edge_exploded_latest_time_window<'graph, G: GraphViewOps<'graph>>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
         w: Range<EventTime>,
     ) -> Option<EventTime> {
         // past the end of the window
@@ -857,10 +946,10 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
 
     fn edge_deletion_history<'graph, G: GraphViewOps<'graph>>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         e.filtered_updates_iter(view, layer_ids)
             .map(|(layer, additions, deletions)| {
                 deletions
@@ -873,10 +962,10 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
 
     fn edge_deletion_history_rev<'graph, G: GraphViewOps<'graph>>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         e.filtered_updates_iter(view, layer_ids)
             .map(|(layer, additions, deletions)| {
                 deletions
@@ -889,11 +978,11 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
 
     fn edge_deletion_history_window<'graph, G: GraphViewOps<'graph>>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         // window for deletions has exclusive start as deletions at the start are not considered part of the window
         let w = EventTime::start(w.start.t().saturating_add(1))..w.end;
         e.filtered_updates_iter(view, layer_ids)
@@ -909,11 +998,11 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
 
     fn edge_deletion_history_window_rev<'graph, G: GraphViewOps<'graph>>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         // window for deletions has exclusive start as deletions at the start are not considered part of the window
         let w = EventTime::start(w.start.t().saturating_add(1))..w.end;
         e.filtered_updates_iter(view, layer_ids)
@@ -929,7 +1018,7 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
 
     fn edge_is_valid<'graph, G: GraphViewOps<'graph>>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
     ) -> bool {
         edge_alive_at_end(e, EventTime::MAX, view)
@@ -937,7 +1026,7 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
 
     fn edge_is_valid_window<'graph, G: GraphViewOps<'graph>>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         r: Range<EventTime>,
     ) -> bool {
@@ -946,7 +1035,7 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
 
     fn edge_is_deleted<'graph, G: GraphViewOps<'graph>>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
     ) -> bool {
         !edge_alive_at_end(e, EventTime::MAX, view)
@@ -954,7 +1043,7 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
 
     fn edge_is_deleted_window<'graph, G: GraphViewOps<'graph>>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         w: Range<EventTime>,
     ) -> bool {
@@ -963,7 +1052,7 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
 
     fn edge_is_active<'graph, G: GraphViewOps<'graph>>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
     ) -> bool {
         e.additions_iter(view.layer_ids())
@@ -974,7 +1063,7 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
 
     fn edge_is_active_window<'graph, G: GraphViewOps<'graph>>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         w: Range<EventTime>,
     ) -> bool {
@@ -990,20 +1079,20 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
 
     fn edge_is_active_exploded<'graph, G: GraphViewOps<'graph>>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
     ) -> bool {
         EventSemantics.edge_is_active_exploded(e, view, t, layer)
     }
 
     fn edge_is_active_exploded_window<'graph, G: GraphViewOps<'graph>>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
         w: Range<EventTime>,
     ) -> bool {
         EventSemantics.edge_is_active_exploded_window(e, view, t, layer, w)
@@ -1012,10 +1101,10 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
     /// An exploded edge is valid if it is the last exploded view and the edge is not deleted (i.e., there are no additions or deletions for the edge after t in the layer)
     fn edge_is_valid_exploded<'graph, G: GraphViewOps<'graph>>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
     ) -> bool {
         !e.filtered_deletions(layer, &view)
             .active(t.next()..EventTime::MAX)
@@ -1029,10 +1118,10 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
     /// (i.e., there are no additions or deletions for the edge after t in the layer in the window)
     fn edge_is_valid_exploded_window<'graph, G: GraphViewOps<'graph>>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
         w: Range<EventTime>,
     ) -> bool {
         !e.filtered_deletions(layer, &view).active(t.next()..w.end)
@@ -1043,10 +1132,10 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
 
     fn edge_exploded_deletion<'graph, G: GraphViewOps<'graph>>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
     ) -> Option<EventTime> {
         let deletions = merged_deletions(e, &view, layer);
         let next_deletion = deletions.range(t.next()..EventTime::MAX).first()?;
@@ -1067,10 +1156,10 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
 
     fn edge_exploded_deletion_window<'graph, G: GraphViewOps<'graph>>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
         w: Range<EventTime>,
     ) -> Option<EventTime> {
         let deletions = merged_deletions(e, &view, layer);
@@ -1092,28 +1181,28 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
 
     fn temporal_edge_prop_exploded<'graph, G: GraphViewOps<'graph>>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         prop_id: usize,
         t: EventTime,
-        layer_id: usize,
+        layer_id: LayerId,
     ) -> Option<Prop> {
         let search_start = merged_deletions(e, &view, layer_id)
             .range(EventTime::MIN..t)
             .last()
             .unwrap_or(EventTime::MIN);
         e.filtered_temporal_prop_layer(layer_id, prop_id, &view)
-            .iter_window(search_start..t.next())
-            .next_back()
+            .iter_inner_rev(Some(search_start..t.next()))
+            .next()
             .map(|(_, v)| v)
     }
 
     fn temporal_edge_prop_exploded_last_at<'graph, G: GraphViewOps<'graph>>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         edge_time: EventTime,
-        layer_id: usize,
+        layer_id: LayerId,
         prop_id: usize,
         at: EventTime,
     ) -> Option<Prop> {
@@ -1133,10 +1222,10 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
 
     fn temporal_edge_prop_exploded_last_at_window<'graph, G: GraphViewOps<'graph>>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         edge_time: EventTime,
-        layer_id: usize,
+        layer_id: LayerId,
         prop_id: usize,
         at: EventTime,
         w: Range<EventTime>,
@@ -1150,7 +1239,7 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
 
     fn temporal_edge_prop_last_at<'graph, G: GraphViewOps<'graph>>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         prop_id: usize,
         t: EventTime,
@@ -1160,7 +1249,7 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
 
     fn temporal_edge_prop_last_at_window<'graph, G: GraphViewOps<'graph>>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         prop_id: usize,
         t: EventTime,
@@ -1176,8 +1265,8 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
                         .map(|t| t.next())
                         .unwrap_or(EventTime::MIN);
                     e.filtered_temporal_prop_layer(layer, prop_id, &view)
-                        .iter_window(start..t.next())
-                        .next_back()
+                        .iter_inner_rev(Some(start..t.next()))
+                        .next()
                 })
                 .max_by(|(t1, _), (t2, _)| t1.cmp(t2))
                 .map(|(_, v)| v)
@@ -1188,78 +1277,76 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
 
     fn temporal_edge_prop_hist<'graph, G: GraphViewOps<'graph>>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         prop_id: usize,
-    ) -> impl Iterator<Item = (EventTime, usize, Prop)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId, Prop)> + Send + Sync + 'graph {
         EventSemantics.temporal_edge_prop_hist(e, view, layer_ids, prop_id)
     }
 
     fn temporal_edge_prop_hist_rev<'graph, G: GraphViewOps<'graph>>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         prop_id: usize,
-    ) -> impl Iterator<Item = (EventTime, usize, Prop)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId, Prop)> + Send + Sync + 'graph {
         EventSemantics.temporal_edge_prop_hist_rev(e, view, layer_ids, prop_id)
     }
 
     fn temporal_edge_prop_hist_window<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         prop_id: usize,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize, Prop)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId, Prop)> + Send + Sync + 'graph {
         e.filtered_temporal_prop_iter(prop_id, view.clone(), layer_ids)
             .map(|(layer, props)| {
-                let deletions = e
-                    .filtered_deletions(layer, &view)
-                    .merge(e.filtered_additions(layer, &view).invert());
-                let first_prop = persisted_prop_value_at(w.start, props.clone(), &deletions)
-                    .map(|(t, v)| (t, layer, v));
+                let additions = e.filtered_additions(layer, &view);
+                let deletions = e.filtered_deletions(layer, &view);
+                let merged_deletions = deletions.clone().merge(additions.clone().invert());
+                let first_prop =
+                    persisted_prop_value_at(w.start, props.clone(), additions, &merged_deletions)
+                        .map(|(t, v)| (t, layer, v));
                 first_prop.into_iter().chain(
                     props
-                        .iter_window(interior_window(w.clone(), &deletions))
+                        .iter_window(interior_window(w.clone(), &merged_deletions))
                         .map(move |(t, v)| (t, layer, v)),
                 )
             })
             .kmerge_by(|(t1, _, _), (t2, _, _)| t1 <= t2)
-            .map(move |(t, layer, v)| (t.max(w.start), layer, v))
     }
 
     fn temporal_edge_prop_hist_window_rev<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         prop_id: usize,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize, Prop)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId, Prop)> + Send + Sync + 'graph {
         e.filtered_temporal_prop_iter(prop_id, view.clone(), layer_ids)
             .map(|(layer, props)| {
-                let deletions = merged_deletions(e, &view, layer);
-                let first_prop = persisted_prop_value_at(w.start, props.clone(), &deletions)
-                    .map(|(t, v)| (t, layer, v));
-                first_prop
-                    .into_iter()
-                    .chain(
-                        props
-                            .iter_window(interior_window(w.clone(), &deletions))
-                            .map(move |(t, v)| (t, layer, v)),
-                    )
-                    .rev()
+                let additions = e.filtered_additions(layer, &view);
+                let deletions = e.filtered_deletions(layer, &view);
+                let merged_deletions = deletions.clone().merge(additions.clone().invert());
+                let first_prop =
+                    persisted_prop_value_at(w.start, props.clone(), additions, &merged_deletions)
+                        .map(|(t, v)| (t, layer, v));
+                props
+                    .iter_inner_rev(Some(interior_window(w.clone(), &merged_deletions)))
+                    .map(move |(t, v)| (t, layer, v))
+                    .chain(first_prop)
             })
             .kmerge_by(|(t1, _, _), (t2, _, _)| t1 >= t2)
-            .map(move |(t, layer, v)| (t.max(w.start), layer, v))
     }
 
     fn edge_metadata<'graph, G: GraphViewOps<'graph>>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         prop_id: usize,
     ) -> Option<Prop> {
@@ -1273,7 +1360,7 @@ impl EdgeTimeSemanticsOps for PersistentSemantics {
 
     fn edge_metadata_window<'graph, G: GraphViewOps<'graph>>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         prop_id: usize,
         w: Range<EventTime>,
diff --git a/raphtory/src/db/api/view/internal/time_semantics/time_semantics.rs b/raphtory/src/db/api/view/internal/time_semantics/time_semantics.rs
index c21b55430c..5293e71898 100644
--- a/raphtory/src/db/api/view/internal/time_semantics/time_semantics.rs
+++ b/raphtory/src/db/api/view/internal/time_semantics/time_semantics.rs
@@ -8,11 +8,12 @@ use crate::db::api::view::internal::{
 };
 use iter_enum::{DoubleEndedIterator, ExactSizeIterator, FusedIterator, Iterator};
 use raphtory_api::core::{
-    entities::{properties::prop::Prop, LayerIds, ELID},
+    entities::{properties::prop::Prop, LayerId, LayerIds, ELID},
     storage::timeindex::EventTime,
 };
-use raphtory_storage::graph::{edges::edge_ref::EdgeStorageRef, nodes::node_ref::NodeStorageRef};
+use raphtory_storage::graph::nodes::node_ref::NodeStorageRef;
 use std::ops::Range;
+use storage::EdgeEntryRef;
 
 #[derive(Clone, Debug)]
 pub enum TimeSemantics {
@@ -83,34 +84,38 @@ impl NodeTimeSemanticsOps for TimeSemantics {
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
     ) -> impl Iterator<Item = EventTime> + Send + Sync + 'graph {
-        for_all_iter!(self, semantics => semantics.node_history(node, view))
+        for_all_iter!(self, semantics => semantics.node_history(node, view, layer_ids))
     }
 
     fn node_history_rev<'graph, G: GraphView + 'graph>(
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
     ) -> impl Iterator<Item = EventTime> + Send + Sync + 'graph {
-        for_all_iter!(self, semantics => semantics.node_history_rev(node, view))
+        for_all_iter!(self, semantics => semantics.node_history_rev(node, view, layer_ids))
     }
 
     fn node_history_window<'graph, G: GraphView + 'graph>(
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
     ) -> impl Iterator<Item = EventTime> + Send + Sync + 'graph {
-        for_all_iter!(self, semantics => semantics.node_history_window(node, view, w))
+        for_all_iter!(self, semantics => semantics.node_history_window(node, view, layer_ids, w))
     }
 
     fn node_history_window_rev<'graph, G: GraphView + 'graph>(
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
     ) -> impl Iterator<Item = EventTime> + Send + Sync + 'graph {
-        for_all_iter!(self, semantics => semantics.node_history_window_rev(node, view, w))
+        for_all_iter!(self, semantics => semantics.node_history_window_rev(node, view, layer_ids, w))
     }
 
     fn node_valid_window<'graph, G: GraphView + 'graph>(
@@ -126,7 +131,7 @@ impl NodeTimeSemanticsOps for TimeSemantics {
         self,
         node: NodeStorageRef<'graph>,
         view: G,
-    ) -> impl Iterator<Item = (EventTime, Vec<(usize, Prop)>)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId, Vec<(usize, Prop)>)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.node_updates(node, view))
     }
 
@@ -135,7 +140,7 @@ impl NodeTimeSemanticsOps for TimeSemantics {
         node: NodeStorageRef<'graph>,
         view: G,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, Vec<(usize, Prop)>)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId, Vec<(usize, Prop)>)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.node_updates_window(node, view, w))
     }
 
@@ -152,20 +157,39 @@ impl NodeTimeSemanticsOps for TimeSemantics {
         node: NodeStorageRef<'graph>,
         view: G,
         prop_id: usize,
-    ) -> impl DoubleEndedIterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.node_tprop_iter(node, view, prop_id))
     }
 
+    fn node_tprop_iter_rev<'graph, G: GraphView + 'graph>(
+        &self,
+        node: NodeStorageRef<'graph>,
+        view: G,
+        prop_id: usize,
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
+        for_all_iter!(self, semantics => semantics.node_tprop_iter_rev(node, view, prop_id))
+    }
+
     fn node_tprop_iter_window<'graph, G: GraphView + 'graph>(
         &self,
         node: NodeStorageRef<'graph>,
         view: G,
         prop_id: usize,
         w: Range<EventTime>,
-    ) -> impl DoubleEndedIterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.node_tprop_iter_window(node, view, prop_id, w))
     }
 
+    fn node_tprop_iter_window_rev<'graph, G: GraphView + 'graph>(
+        &self,
+        node: NodeStorageRef<'graph>,
+        view: G,
+        prop_id: usize,
+        w: Range<EventTime>,
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
+        for_all_iter!(self, semantics => semantics.node_tprop_iter_window_rev(node, view, prop_id, w))
+    }
+
     fn node_tprop_last_at<'graph, G: GraphView + 'graph>(
         &self,
         node: NodeStorageRef<'graph>,
@@ -208,34 +232,38 @@ impl NodeTimeSemanticsOps for TimeSemantics {
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
     ) -> impl Iterator<Item = (EventTime, ELID)> + Send + Sync + 'graph {
-        for_all_iter!(self, semantics => semantics.node_edge_history(node, view))
+        for_all_iter!(self, semantics => semantics.node_edge_history(node, view, layer_ids))
     }
 
     fn node_edge_history_window<'graph, G: GraphView + 'graph>(
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
     ) -> impl Iterator<Item = (EventTime, ELID)> + Send + Sync + 'graph {
-        for_all_iter!(self, semantics => semantics.node_edge_history_window(node, view, w))
+        for_all_iter!(self, semantics => semantics.node_edge_history_window(node, view,layer_ids, w))
     }
 
     fn node_edge_history_rev<'graph, G: GraphView + 'graph>(
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
     ) -> impl Iterator<Item = (EventTime, ELID)> + Send + Sync + 'graph {
-        for_all_iter!(self, semantics => semantics.node_edge_history_rev(node, view))
+        for_all_iter!(self, semantics => semantics.node_edge_history_rev(node, view, layer_ids))
     }
 
     fn node_edge_history_rev_window<'graph, G: GraphView + 'graph>(
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
     ) -> impl Iterator<Item = (EventTime, ELID)> + Send + Sync + 'graph {
-        for_all_iter!(self, semantics => semantics.node_edge_history_rev_window(node, view, w))
+        for_all_iter!(self, semantics => semantics.node_edge_history_rev_window(node, view, layer_ids, w))
     }
 }
 
@@ -249,15 +277,15 @@ impl EdgeTimeSemanticsOps for TimeSemantics {
         for_all!(self, semantics => semantics.handle_edge_update_filter(t, eid, view))
     }
 
-    fn include_edge<G: GraphView>(&self, edge: EdgeStorageRef, view: G, layer_id: usize) -> bool {
+    fn include_edge<G: GraphView>(&self, edge: EdgeEntryRef, view: G, layer_id: LayerId) -> bool {
         for_all!(self, semantics => semantics.include_edge(edge, view, layer_id))
     }
 
     fn include_edge_window<G: GraphView>(
         &self,
-        edge: EdgeStorageRef,
+        edge: EdgeEntryRef,
         view: G,
-        layer_id: usize,
+        layer_id: LayerId,
         w: Range<EventTime>,
     ) -> bool {
         for_all!(self, semantics => semantics.include_edge_window(edge, view, layer_id, w))
@@ -279,45 +307,45 @@ impl EdgeTimeSemanticsOps for TimeSemantics {
 
     fn edge_history<'graph, G: GraphView + 'graph>(
         self,
-        edge: EdgeStorageRef<'graph>,
+        edge: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.edge_history(edge, view, layer_ids))
     }
 
     fn edge_history_rev<'graph, G: GraphView + 'graph>(
         self,
-        edge: EdgeStorageRef<'graph>,
+        edge: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.edge_history_rev(edge, view, layer_ids))
     }
 
     fn edge_history_window<'graph, G: GraphView + 'graph>(
         self,
-        edge: EdgeStorageRef<'graph>,
+        edge: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.edge_history_window(edge, view, layer_ids, w))
     }
 
     fn edge_history_window_rev<'graph, G: GraphView + 'graph>(
         self,
-        edge: EdgeStorageRef<'graph>,
+        edge: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.edge_history_window_rev(edge, view, layer_ids, w))
     }
 
     fn edge_exploded_count<'graph, G: GraphView + 'graph>(
         &self,
-        edge: EdgeStorageRef,
+        edge: EdgeEntryRef,
         view: G,
     ) -> usize {
         for_all!(self, semantics => semantics.edge_exploded_count(edge, view))
@@ -325,7 +353,7 @@ impl EdgeTimeSemanticsOps for TimeSemantics {
 
     fn edge_exploded_count_window<'graph, G: GraphView + 'graph>(
         &self,
-        edge: EdgeStorageRef,
+        edge: EdgeEntryRef,
         view: G,
         w: Range<EventTime>,
     ) -> usize {
@@ -334,45 +362,45 @@ impl EdgeTimeSemanticsOps for TimeSemantics {
 
     fn edge_exploded<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.edge_exploded(e, view, layer_ids))
     }
 
     fn edge_layers<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = usize> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = LayerId> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.edge_layers(e, view, layer_ids))
     }
 
     fn edge_window_exploded<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.edge_window_exploded(e, view, layer_ids, w))
     }
 
     fn edge_window_layers<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = usize> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = LayerId> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.edge_window_layers(e, view, layer_ids, w))
     }
 
     fn edge_earliest_time<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
     ) -> Option<EventTime> {
         for_all!(self, semantics => semantics.edge_earliest_time(e, view))
@@ -380,7 +408,7 @@ impl EdgeTimeSemanticsOps for TimeSemantics {
 
     fn edge_earliest_time_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         w: Range<EventTime>,
     ) -> Option<EventTime> {
@@ -389,20 +417,20 @@ impl EdgeTimeSemanticsOps for TimeSemantics {
 
     fn edge_exploded_earliest_time<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
     ) -> Option<EventTime> {
         for_all!(self, semantics => semantics.edge_exploded_earliest_time(e, view, t, layer))
     }
 
     fn edge_exploded_earliest_time_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
         w: Range<EventTime>,
     ) -> Option<EventTime> {
         for_all!(self, semantics => semantics.edge_exploded_earliest_time_window(e, view, t, layer, w))
@@ -410,7 +438,7 @@ impl EdgeTimeSemanticsOps for TimeSemantics {
 
     fn edge_latest_time<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
     ) -> Option<EventTime> {
         for_all!(self, semantics => semantics.edge_latest_time(e, view))
@@ -418,7 +446,7 @@ impl EdgeTimeSemanticsOps for TimeSemantics {
 
     fn edge_latest_time_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         w: Range<EventTime>,
     ) -> Option<EventTime> {
@@ -427,20 +455,20 @@ impl EdgeTimeSemanticsOps for TimeSemantics {
 
     fn edge_exploded_latest_time<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
     ) -> Option<EventTime> {
         for_all!(self, semantics => semantics.edge_exploded_latest_time(e, view, t, layer))
     }
 
     fn edge_exploded_latest_time_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
         w: Range<EventTime>,
     ) -> Option<EventTime> {
         for_all!(self, semantics => semantics.edge_exploded_latest_time_window(e, view, t, layer, w))
@@ -448,45 +476,45 @@ impl EdgeTimeSemanticsOps for TimeSemantics {
 
     fn edge_deletion_history<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.edge_deletion_history(e, view, layer_ids))
     }
 
     fn edge_deletion_history_rev<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.edge_deletion_history_rev(e, view, layer_ids))
     }
 
     fn edge_deletion_history_window<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.edge_deletion_history_window(e, view, layer_ids, w))
     }
 
     fn edge_deletion_history_window_rev<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.edge_deletion_history_window_rev(e, view, layer_ids, w))
     }
 
     fn edge_is_valid<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
     ) -> bool {
         for_all!(self, semantics => semantics.edge_is_valid(e, view))
@@ -494,7 +522,7 @@ impl EdgeTimeSemanticsOps for TimeSemantics {
 
     fn edge_is_valid_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         r: Range<EventTime>,
     ) -> bool {
@@ -503,7 +531,7 @@ impl EdgeTimeSemanticsOps for TimeSemantics {
 
     fn edge_is_deleted<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
     ) -> bool {
         for_all!(self, semantics => semantics.edge_is_deleted(e, view))
@@ -511,7 +539,7 @@ impl EdgeTimeSemanticsOps for TimeSemantics {
 
     fn edge_is_deleted_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         w: Range<EventTime>,
     ) -> bool {
@@ -520,7 +548,7 @@ impl EdgeTimeSemanticsOps for TimeSemantics {
 
     fn edge_is_active<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
     ) -> bool {
         for_all!(self, semantics => semantics.edge_is_active(e, view))
@@ -528,7 +556,7 @@ impl EdgeTimeSemanticsOps for TimeSemantics {
 
     fn edge_is_active_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         w: Range<EventTime>,
     ) -> bool {
@@ -537,20 +565,20 @@ impl EdgeTimeSemanticsOps for TimeSemantics {
 
     fn edge_is_active_exploded<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
     ) -> bool {
         for_all!(self, semantics => semantics.edge_is_active_exploded(e, view, t, layer))
     }
 
     fn edge_is_active_exploded_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
         w: Range<EventTime>,
     ) -> bool {
         for_all!(self, semantics => semantics.edge_is_active_exploded_window(e, view, t, layer, w))
@@ -558,20 +586,20 @@ impl EdgeTimeSemanticsOps for TimeSemantics {
 
     fn edge_is_valid_exploded<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
     ) -> bool {
         for_all!(self, semantics => semantics.edge_is_valid_exploded(e, view, t, layer))
     }
 
     fn edge_is_valid_exploded_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
         w: Range<EventTime>,
     ) -> bool {
         for_all!(self, semantics => semantics.edge_is_valid_exploded_window(e, view, t, layer, w))
@@ -579,20 +607,20 @@ impl EdgeTimeSemanticsOps for TimeSemantics {
 
     fn edge_exploded_deletion<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
     ) -> Option<EventTime> {
         for_all!(self, semantics => semantics.edge_exploded_deletion(e, view, t, layer))
     }
 
     fn edge_exploded_deletion_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
         w: Range<EventTime>,
     ) -> Option<EventTime> {
         for_all!(self, semantics => semantics.edge_exploded_deletion_window(e, view, t, layer, w))
@@ -600,21 +628,21 @@ impl EdgeTimeSemanticsOps for TimeSemantics {
 
     fn temporal_edge_prop_exploded<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         prop_id: usize,
         t: EventTime,
-        layer_id: usize,
+        layer_id: LayerId,
     ) -> Option<Prop> {
         for_all!(self, semantics => semantics.temporal_edge_prop_exploded(e, view, prop_id, t, layer_id))
     }
 
     fn temporal_edge_prop_exploded_last_at<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         edge_time: EventTime,
-        layer_id: usize,
+        layer_id: LayerId,
         prop_id: usize,
         at: EventTime,
     ) -> Option<Prop> {
@@ -623,10 +651,10 @@ impl EdgeTimeSemanticsOps for TimeSemantics {
 
     fn temporal_edge_prop_exploded_last_at_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         edge_time: EventTime,
-        layer_id: usize,
+        layer_id: LayerId,
         prop_id: usize,
         at: EventTime,
         w: Range<EventTime>,
@@ -636,7 +664,7 @@ impl EdgeTimeSemanticsOps for TimeSemantics {
 
     fn temporal_edge_prop_last_at<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         prop_id: usize,
         t: EventTime,
@@ -646,7 +674,7 @@ impl EdgeTimeSemanticsOps for TimeSemantics {
 
     fn temporal_edge_prop_last_at_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         prop_id: usize,
         t: EventTime,
@@ -657,43 +685,43 @@ impl EdgeTimeSemanticsOps for TimeSemantics {
 
     fn temporal_edge_prop_hist<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         prop_id: usize,
-    ) -> impl Iterator<Item = (EventTime, usize, Prop)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId, Prop)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.temporal_edge_prop_hist(e, view, layer_ids, prop_id))
     }
 
     fn temporal_edge_prop_hist_rev<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         prop_id: usize,
-    ) -> impl Iterator<Item = (EventTime, usize, Prop)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId, Prop)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.temporal_edge_prop_hist_rev(e, view, layer_ids, prop_id))
     }
 
     fn temporal_edge_prop_hist_window<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         prop_id: usize,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize, Prop)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId, Prop)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.temporal_edge_prop_hist_window(e, view, layer_ids, prop_id, w))
     }
 
     fn temporal_edge_prop_hist_window_rev<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         prop_id: usize,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize, Prop)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId, Prop)> + Send + Sync + 'graph {
         for_all_iter!(self, semantics => semantics.temporal_edge_prop_hist_window_rev(e, view, layer_ids, prop_id, w))
     }
 
@@ -703,7 +731,7 @@ impl EdgeTimeSemanticsOps for TimeSemantics {
     ///     PropValue:
     fn edge_metadata<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         prop_id: usize,
     ) -> Option<Prop> {
@@ -712,7 +740,7 @@ impl EdgeTimeSemanticsOps for TimeSemantics {
 
     fn edge_metadata_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         prop_id: usize,
         w: Range<EventTime>,
diff --git a/raphtory/src/db/api/view/internal/time_semantics/time_semantics_ops.rs b/raphtory/src/db/api/view/internal/time_semantics/time_semantics_ops.rs
index ae3c87a7fd..9899e752db 100644
--- a/raphtory/src/db/api/view/internal/time_semantics/time_semantics_ops.rs
+++ b/raphtory/src/db/api/view/internal/time_semantics/time_semantics_ops.rs
@@ -1,10 +1,11 @@
 use crate::db::api::view::internal::GraphView;
 use raphtory_api::core::{
-    entities::{properties::prop::Prop, LayerIds, ELID},
+    entities::{properties::prop::Prop, LayerId, LayerIds, ELID},
     storage::timeindex::EventTime,
 };
-use raphtory_storage::graph::{edges::edge_ref::EdgeStorageRef, nodes::node_ref::NodeStorageRef};
+use raphtory_storage::graph::nodes::node_ref::NodeStorageRef;
 use std::ops::Range;
+use storage::EdgeEntryRef;
 
 pub trait NodeTimeSemanticsOps {
     fn node_earliest_time<'graph, G: GraphView + 'graph>(
@@ -37,18 +38,21 @@ pub trait NodeTimeSemanticsOps {
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
     ) -> impl Iterator<Item = EventTime> + Send + Sync + 'graph;
 
     fn node_history_rev<'graph, G: GraphView + 'graph>(
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
     ) -> impl Iterator<Item = EventTime> + Send + Sync + 'graph;
 
     fn node_history_window<'graph, G: GraphView + 'graph>(
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
     ) -> impl Iterator<Item = EventTime> + Send + Sync + 'graph;
 
@@ -56,6 +60,7 @@ pub trait NodeTimeSemanticsOps {
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
     ) -> impl Iterator<Item = EventTime> + Send + Sync + 'graph;
 
@@ -76,12 +81,14 @@ pub trait NodeTimeSemanticsOps {
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
     ) -> impl Iterator<Item = (EventTime, ELID)> + Send + Sync + 'graph;
 
     fn node_edge_history_window<'graph, G: GraphView + 'graph>(
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
     ) -> impl Iterator<Item = (EventTime, ELID)> + Send + Sync + 'graph;
 
@@ -89,12 +96,14 @@ pub trait NodeTimeSemanticsOps {
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
     ) -> impl Iterator<Item = (EventTime, ELID)> + Send + Sync + 'graph;
 
     fn node_edge_history_rev_window<'graph, G: GraphView + 'graph>(
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
     ) -> impl Iterator<Item = (EventTime, ELID)> + Send + Sync + 'graph;
 
@@ -102,14 +111,14 @@ pub trait NodeTimeSemanticsOps {
         self,
         node: NodeStorageRef<'graph>,
         view: G,
-    ) -> impl Iterator<Item = (EventTime, Vec<(usize, Prop)>)> + Send + Sync + 'graph;
+    ) -> impl Iterator<Item = (EventTime, LayerId, Vec<(usize, Prop)>)> + Send + Sync + 'graph;
 
     fn node_updates_window<'graph, G: GraphView + 'graph>(
         self,
         node: NodeStorageRef<'graph>,
         view: G,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, Vec<(usize, Prop)>)> + Send + Sync + 'graph;
+    ) -> impl Iterator<Item = (EventTime, LayerId, Vec<(usize, Prop)>)> + Send + Sync + 'graph;
 
     /// Check if the node is part of the graph based on the history
     fn node_valid<'graph, G: GraphView + 'graph>(
@@ -130,7 +139,14 @@ pub trait NodeTimeSemanticsOps {
         node: NodeStorageRef<'graph>,
         view: G,
         prop_id: usize,
-    ) -> impl DoubleEndedIterator<Item = (EventTime, Prop)> + Send + Sync + 'graph;
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'graph;
+
+    fn node_tprop_iter_rev<'graph, G: GraphView + 'graph>(
+        &self,
+        node: NodeStorageRef<'graph>,
+        view: G,
+        prop_id: usize,
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'graph;
 
     fn node_tprop_iter_window<'graph, G: GraphView + 'graph>(
         &self,
@@ -138,7 +154,15 @@ pub trait NodeTimeSemanticsOps {
         view: G,
         prop_id: usize,
         w: Range<EventTime>,
-    ) -> impl DoubleEndedIterator<Item = (EventTime, Prop)> + Send + Sync + 'graph;
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'graph;
+
+    fn node_tprop_iter_window_rev<'graph, G: GraphView + 'graph>(
+        &self,
+        node: NodeStorageRef<'graph>,
+        view: G,
+        prop_id: usize,
+        w: Range<EventTime>,
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'graph;
 
     fn node_tprop_last_at<'graph, G: GraphView + 'graph>(
         &self,
@@ -166,14 +190,14 @@ pub trait EdgeTimeSemanticsOps {
         view: G,
     ) -> Option<(EventTime, ELID)>;
 
-    fn include_edge<G: GraphView>(&self, edge: EdgeStorageRef, view: G, layer_id: usize) -> bool;
+    fn include_edge<G: GraphView>(&self, edge: EdgeEntryRef, view: G, layer_id: LayerId) -> bool;
 
     /// check if edge `e` should be included in window `w`
     fn include_edge_window<G: GraphView>(
         &self,
-        edge: EdgeStorageRef,
+        edge: EdgeEntryRef,
         view: G,
-        layer_id: usize,
+        layer_id: LayerId,
         w: Range<EventTime>,
     ) -> bool;
 
@@ -196,10 +220,10 @@ pub trait EdgeTimeSemanticsOps {
     /// An iterator over timestamp and layer pairs
     fn edge_history<'graph, G: GraphView + 'graph>(
         self,
-        edge: EdgeStorageRef<'graph>,
+        edge: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph;
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph;
 
     /// returns the update history of an edge in reverse
     ///
@@ -208,10 +232,10 @@ pub trait EdgeTimeSemanticsOps {
     /// An iterator over timestamp and layer pairs
     fn edge_history_rev<'graph, G: GraphView + 'graph>(
         self,
-        edge: EdgeStorageRef<'graph>,
+        edge: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph;
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph;
 
     /// returns the update history of an edge in a window
     ///
@@ -220,11 +244,11 @@ pub trait EdgeTimeSemanticsOps {
     /// An iterator over timestamp and layer pairs
     fn edge_history_window<'graph, G: GraphView + 'graph>(
         self,
-        edge: EdgeStorageRef<'graph>,
+        edge: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph;
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph;
 
     /// returns the update history of an edge in a window in reverse
     ///
@@ -233,23 +257,23 @@ pub trait EdgeTimeSemanticsOps {
     /// An iterator over timestamp and layer pairs
     fn edge_history_window_rev<'graph, G: GraphView + 'graph>(
         self,
-        edge: EdgeStorageRef<'graph>,
+        edge: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph;
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph;
 
     /// The number of exploded edge events for the `edge`
     fn edge_exploded_count<'graph, G: GraphView + 'graph>(
         &self,
-        edge: EdgeStorageRef,
+        edge: EdgeEntryRef,
         view: G,
     ) -> usize;
 
     /// The number of exploded edge events for the edge in the window `w`
     fn edge_exploded_count_window<'graph, G: GraphView + 'graph>(
         &self,
-        edge: EdgeStorageRef,
+        edge: EdgeEntryRef,
         view: G,
         w: Range<EventTime>,
     ) -> usize;
@@ -257,139 +281,139 @@ pub trait EdgeTimeSemanticsOps {
     /// Exploded edge iterator for edge `e`
     fn edge_exploded<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph;
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph;
 
     /// Explode edge iterator for edge `e` for every layer
     fn edge_layers<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = usize> + Send + Sync + 'graph;
+    ) -> impl Iterator<Item = LayerId> + Send + Sync + 'graph;
 
     /// Exploded edge iterator for edge`e` over window `w`
     fn edge_window_exploded<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph;
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph;
 
     /// Exploded edge iterator for edge `e` over window `w` for every layer
     fn edge_window_layers<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = usize> + Send + Sync + 'graph;
+    ) -> impl Iterator<Item = LayerId> + Send + Sync + 'graph;
 
     /// Get the time of the earliest activity of an edge
     fn edge_earliest_time<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
     ) -> Option<EventTime>;
 
     /// Get the time of the earliest activity of an edge `e` in window `w`
     fn edge_earliest_time_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         w: Range<EventTime>,
     ) -> Option<EventTime>;
 
     fn edge_exploded_earliest_time<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
     ) -> Option<EventTime>;
 
     fn edge_exploded_earliest_time_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
         w: Range<EventTime>,
     ) -> Option<EventTime>;
 
     /// Get the time of the latest activity of an edge
     fn edge_latest_time<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
     ) -> Option<EventTime>;
 
     /// Get the time of the latest activity of an edge `e` in window `w`
     fn edge_latest_time_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         w: Range<EventTime>,
     ) -> Option<EventTime>;
 
     fn edge_exploded_latest_time<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
     ) -> Option<EventTime>;
 
     fn edge_exploded_latest_time_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
         w: Range<EventTime>,
     ) -> Option<EventTime>;
 
     /// Get the edge deletions for use with materialize
     fn edge_deletion_history<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph;
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph;
 
     /// Get the edge deletions in reverse order for use with materialize
     fn edge_deletion_history_rev<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph;
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph;
 
     /// Get the edge deletions for use with materialize restricted to window `w`
     fn edge_deletion_history_window<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph;
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph;
 
     /// Get the edge deletions in reverse order for use with materialize restricted to window `w`
     fn edge_deletion_history_window_rev<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph;
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph;
 
     /// Check if  edge `e` is currently valid in any layer included in the view
     fn edge_is_valid<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
     ) -> bool;
 
@@ -397,104 +421,104 @@ pub trait EdgeTimeSemanticsOps {
     /// in any layer included in the view
     fn edge_is_valid_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         r: Range<EventTime>,
     ) -> bool;
 
     fn edge_is_deleted<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
     ) -> bool;
 
     fn edge_is_deleted_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         w: Range<EventTime>,
     ) -> bool;
 
     fn edge_is_active<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
     ) -> bool;
 
     fn edge_is_active_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         w: Range<EventTime>,
     ) -> bool;
 
     fn edge_is_active_exploded<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
     ) -> bool;
 
     fn edge_is_active_exploded_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
         w: Range<EventTime>,
     ) -> bool;
 
     fn edge_is_valid_exploded<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
     ) -> bool;
 
     fn edge_is_valid_exploded_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
         w: Range<EventTime>,
     ) -> bool;
 
     fn edge_exploded_deletion<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
     ) -> Option<EventTime>;
 
     fn edge_exploded_deletion_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
         w: Range<EventTime>,
     ) -> Option<EventTime>;
 
     fn edge_is_deleted_exploded<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
     ) -> bool {
         self.edge_exploded_deletion(e, view, t, layer).is_some()
     }
 
     fn edge_is_deleted_exploded_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
         w: Range<EventTime>,
     ) -> bool {
         self.edge_exploded_deletion_window(e, view, t, layer, w)
@@ -504,29 +528,29 @@ pub trait EdgeTimeSemanticsOps {
     /// Return the value of an edge temporal property at a given point in time and layer if it exists
     fn temporal_edge_prop_exploded<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         prop_id: usize,
         t: EventTime,
-        layer_id: usize,
+        layer_id: LayerId,
     ) -> Option<Prop>;
 
     fn temporal_edge_prop_exploded_last_at<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         edge_time: EventTime,
-        layer_id: usize,
+        layer_id: LayerId,
         prop_id: usize,
         at: EventTime,
     ) -> Option<Prop>;
 
     fn temporal_edge_prop_exploded_last_at_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         edge_time: EventTime,
-        layer_id: usize,
+        layer_id: LayerId,
         prop_id: usize,
         at: EventTime,
         w: Range<EventTime>,
@@ -535,7 +559,7 @@ pub trait EdgeTimeSemanticsOps {
     /// Return the last value of a temporal edge property at or before a given point in time
     fn temporal_edge_prop_last_at<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         prop_id: usize,
         t: EventTime,
@@ -543,7 +567,7 @@ pub trait EdgeTimeSemanticsOps {
 
     fn temporal_edge_prop_last_at_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         prop_id: usize,
         t: EventTime,
@@ -555,22 +579,22 @@ pub trait EdgeTimeSemanticsOps {
     /// Items are (timestamp, layer_id, property value)
     fn temporal_edge_prop_hist<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         prop_id: usize,
-    ) -> impl Iterator<Item = (EventTime, usize, Prop)> + Send + Sync + 'graph;
+    ) -> impl Iterator<Item = (EventTime, LayerId, Prop)> + Send + Sync + 'graph;
 
     /// Return property history for an edge in reverse-temporal order
     ///
     /// Items are (timestamp, layer_id, property value)
     fn temporal_edge_prop_hist_rev<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         prop_id: usize,
-    ) -> impl Iterator<Item = (EventTime, usize, Prop)> + Send + Sync + 'graph;
+    ) -> impl Iterator<Item = (EventTime, LayerId, Prop)> + Send + Sync + 'graph;
 
     /// Returns an Iterator of tuples containing the values of the temporal property with the given name
     /// for the given edge reference within the specified time window.
@@ -585,24 +609,24 @@ pub trait EdgeTimeSemanticsOps {
     /// Items are (timestamp, layer_id, property value)
     fn temporal_edge_prop_hist_window<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         prop_id: usize,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize, Prop)> + Send + Sync + 'graph;
+    ) -> impl Iterator<Item = (EventTime, LayerId, Prop)> + Send + Sync + 'graph;
 
     /// Return temporal property history for a window of an edge in reverse-temporal order
     ///
     /// Items are (timestamp, layer_id, property value)
     fn temporal_edge_prop_hist_window_rev<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         prop_id: usize,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize, Prop)> + Send + Sync + 'graph;
+    ) -> impl Iterator<Item = (EventTime, LayerId, Prop)> + Send + Sync + 'graph;
 
     /// Get edge metadata
     ///
@@ -610,7 +634,7 @@ pub trait EdgeTimeSemanticsOps {
     ///     PropValue:
     fn edge_metadata<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         prop_id: usize,
     ) -> Option<Prop>;
@@ -620,7 +644,7 @@ pub trait EdgeTimeSemanticsOps {
     /// Should only return the property for a layer if the edge exists in the window in that layer
     fn edge_metadata_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         prop_id: usize,
         w: Range<EventTime>,
diff --git a/raphtory/src/db/api/view/internal/time_semantics/window_time_semantics.rs b/raphtory/src/db/api/view/internal/time_semantics/window_time_semantics.rs
index 2664c121d6..05b520559a 100644
--- a/raphtory/src/db/api/view/internal/time_semantics/window_time_semantics.rs
+++ b/raphtory/src/db/api/view/internal/time_semantics/window_time_semantics.rs
@@ -5,11 +5,12 @@ use crate::db::api::view::internal::{
     EdgeTimeSemanticsOps, GraphView,
 };
 use raphtory_api::core::{
-    entities::{properties::prop::Prop, LayerIds, ELID},
+    entities::{properties::prop::Prop, LayerId, LayerIds, ELID},
     storage::timeindex::EventTime,
 };
-use raphtory_storage::graph::{edges::edge_ref::EdgeStorageRef, nodes::node_ref::NodeStorageRef};
+use raphtory_storage::graph::nodes::node_ref::NodeStorageRef;
 use std::ops::Range;
+use storage::EdgeEntryRef;
 
 #[derive(Clone, Debug)]
 pub struct WindowTimeSemantics {
@@ -74,9 +75,10 @@ impl NodeTimeSemanticsOps for WindowTimeSemantics {
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
     ) -> impl Iterator<Item = EventTime> + Send + Sync + 'graph {
         self.semantics
-            .node_history_window(node, view, self.window.clone())
+            .node_history_window(node, view, layer_ids, self.window.clone())
     }
 
     #[inline]
@@ -84,9 +86,10 @@ impl NodeTimeSemanticsOps for WindowTimeSemantics {
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
     ) -> impl Iterator<Item = EventTime> + Send + Sync + 'graph {
         self.semantics
-            .node_history_window_rev(node, view, self.window.clone())
+            .node_history_window_rev(node, view, layer_ids, self.window.clone())
     }
 
     #[inline]
@@ -94,9 +97,10 @@ impl NodeTimeSemanticsOps for WindowTimeSemantics {
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
     ) -> impl Iterator<Item = EventTime> + Send + Sync + 'graph {
-        self.semantics.node_history_window(node, view, w)
+        self.semantics.node_history_window(node, view, layer_ids, w)
     }
 
     #[inline]
@@ -104,9 +108,11 @@ impl NodeTimeSemanticsOps for WindowTimeSemantics {
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
     ) -> impl Iterator<Item = EventTime> + Send + Sync + 'graph {
-        self.semantics.node_history_window_rev(node, view, w)
+        self.semantics
+            .node_history_window_rev(node, view, layer_ids, w)
     }
 
     #[inline]
@@ -134,9 +140,10 @@ impl NodeTimeSemanticsOps for WindowTimeSemantics {
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
     ) -> impl Iterator<Item = (EventTime, ELID)> + Send + Sync + 'graph {
         self.semantics
-            .node_edge_history_window(node, view, self.window.clone())
+            .node_edge_history_window(node, view, layer_ids, self.window.clone())
     }
 
     #[inline]
@@ -144,34 +151,39 @@ impl NodeTimeSemanticsOps for WindowTimeSemantics {
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
     ) -> impl Iterator<Item = (EventTime, ELID)> + Send + Sync + 'graph {
-        self.semantics.node_edge_history_window(node, view, w)
+        self.semantics
+            .node_edge_history_window(node, view, layer_ids, w)
     }
     #[inline]
     fn node_edge_history_rev<'graph, G: GraphView + 'graph>(
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
     ) -> impl Iterator<Item = (EventTime, ELID)> + Send + Sync + 'graph {
         self.semantics
-            .node_edge_history_rev_window(node, view, self.window.clone())
+            .node_edge_history_rev_window(node, view, layer_ids, self.window.clone())
     }
     #[inline]
     fn node_edge_history_rev_window<'graph, G: GraphView + 'graph>(
         self,
         node: NodeStorageRef<'graph>,
         view: G,
+        layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
     ) -> impl Iterator<Item = (EventTime, ELID)> + Send + Sync + 'graph {
-        self.semantics.node_edge_history_rev_window(node, view, w)
+        self.semantics
+            .node_edge_history_rev_window(node, view, layer_ids, w)
     }
     #[inline]
     fn node_updates<'graph, G: GraphView + 'graph>(
         self,
         node: NodeStorageRef<'graph>,
         view: G,
-    ) -> impl Iterator<Item = (EventTime, Vec<(usize, Prop)>)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId, Vec<(usize, Prop)>)> + Send + Sync + 'graph {
         self.semantics
             .node_updates_window(node, view, self.window.clone())
     }
@@ -182,7 +194,7 @@ impl NodeTimeSemanticsOps for WindowTimeSemantics {
         node: NodeStorageRef<'graph>,
         view: G,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, Vec<(usize, Prop)>)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId, Vec<(usize, Prop)>)> + Send + Sync + 'graph {
         self.semantics.node_updates_window(node, view, w)
     }
 
@@ -212,11 +224,22 @@ impl NodeTimeSemanticsOps for WindowTimeSemantics {
         node: NodeStorageRef<'graph>,
         view: G,
         prop_id: usize,
-    ) -> impl DoubleEndedIterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
         self.semantics
             .node_tprop_iter_window(node, view, prop_id, self.window.clone())
     }
 
+    #[inline]
+    fn node_tprop_iter_rev<'graph, G: GraphView + 'graph>(
+        &self,
+        node: NodeStorageRef<'graph>,
+        view: G,
+        prop_id: usize,
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
+        self.semantics
+            .node_tprop_iter_window_rev(node, view, prop_id, self.window.clone())
+    }
+
     #[inline]
     fn node_tprop_iter_window<'graph, G: GraphView + 'graph>(
         &self,
@@ -224,11 +247,23 @@ impl NodeTimeSemanticsOps for WindowTimeSemantics {
         view: G,
         prop_id: usize,
         w: Range<EventTime>,
-    ) -> impl DoubleEndedIterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
         self.semantics
             .node_tprop_iter_window(node, view, prop_id, w)
     }
 
+    #[inline]
+    fn node_tprop_iter_window_rev<'graph, G: GraphView + 'graph>(
+        &self,
+        node: NodeStorageRef<'graph>,
+        view: G,
+        prop_id: usize,
+        w: Range<EventTime>,
+    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
+        self.semantics
+            .node_tprop_iter_window_rev(node, view, prop_id, w)
+    }
+
     #[inline]
     fn node_tprop_last_at<'graph, G: GraphView + 'graph>(
         &self,
@@ -265,7 +300,7 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
         self.semantics.handle_edge_update_filter(t, eid, view)
     }
 
-    fn include_edge<G: GraphView>(&self, edge: EdgeStorageRef, view: G, layer_id: usize) -> bool {
+    fn include_edge<G: GraphView>(&self, edge: EdgeEntryRef, view: G, layer_id: LayerId) -> bool {
         self.semantics
             .include_edge_window(edge, view, layer_id, self.window.clone())
     }
@@ -273,9 +308,9 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn include_edge_window<G: GraphView>(
         &self,
-        edge: EdgeStorageRef,
+        edge: EdgeEntryRef,
         view: G,
-        layer_id: usize,
+        layer_id: LayerId,
         w: Range<EventTime>,
     ) -> bool {
         self.semantics.include_edge_window(edge, view, layer_id, w)
@@ -300,10 +335,10 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn edge_history<'graph, G: GraphView + 'graph>(
         self,
-        edge: EdgeStorageRef<'graph>,
+        edge: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         self.semantics
             .edge_history_window(edge, view, layer_ids, self.window)
     }
@@ -311,10 +346,10 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn edge_history_rev<'graph, G: GraphView + 'graph>(
         self,
-        edge: EdgeStorageRef<'graph>,
+        edge: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         self.semantics
             .edge_history_window_rev(edge, view, layer_ids, self.window)
     }
@@ -322,22 +357,22 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn edge_history_window<'graph, G: GraphView + 'graph>(
         self,
-        edge: EdgeStorageRef<'graph>,
+        edge: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         self.semantics.edge_history_window(edge, view, layer_ids, w)
     }
 
     #[inline]
     fn edge_history_window_rev<'graph, G: GraphView + 'graph>(
         self,
-        edge: EdgeStorageRef<'graph>,
+        edge: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         self.semantics
             .edge_history_window_rev(edge, view, layer_ids, w)
     }
@@ -345,7 +380,7 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn edge_exploded_count<'graph, G: GraphView + 'graph>(
         &self,
-        edge: EdgeStorageRef,
+        edge: EdgeEntryRef,
         view: G,
     ) -> usize {
         self.semantics
@@ -355,7 +390,7 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn edge_exploded_count_window<'graph, G: GraphView + 'graph>(
         &self,
-        edge: EdgeStorageRef,
+        edge: EdgeEntryRef,
         view: G,
         w: Range<EventTime>,
     ) -> usize {
@@ -365,10 +400,10 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn edge_exploded<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         self.semantics
             .edge_window_exploded(e, view, layer_ids, self.window)
     }
@@ -376,10 +411,10 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn edge_layers<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = usize> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = LayerId> + Send + Sync + 'graph {
         self.semantics
             .edge_window_layers(e, view, layer_ids, self.window)
     }
@@ -387,29 +422,29 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn edge_window_exploded<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         self.semantics.edge_window_exploded(e, view, layer_ids, w)
     }
 
     #[inline]
     fn edge_window_layers<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = usize> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = LayerId> + Send + Sync + 'graph {
         self.semantics.edge_window_layers(e, view, layer_ids, w)
     }
 
     #[inline]
     fn edge_earliest_time<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
     ) -> Option<EventTime> {
         self.semantics
@@ -419,7 +454,7 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn edge_earliest_time_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         w: Range<EventTime>,
     ) -> Option<EventTime> {
@@ -429,10 +464,10 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn edge_exploded_earliest_time<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
     ) -> Option<EventTime> {
         self.semantics
             .edge_exploded_earliest_time_window(e, view, t, layer, self.window.clone())
@@ -441,10 +476,10 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn edge_exploded_earliest_time_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
         w: Range<EventTime>,
     ) -> Option<EventTime> {
         self.semantics
@@ -454,7 +489,7 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn edge_latest_time<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
     ) -> Option<EventTime> {
         self.semantics
@@ -464,7 +499,7 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn edge_latest_time_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         w: Range<EventTime>,
     ) -> Option<EventTime> {
@@ -474,10 +509,10 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn edge_exploded_latest_time<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
     ) -> Option<EventTime> {
         self.semantics
             .edge_exploded_latest_time_window(e, view, t, layer, self.window.clone())
@@ -486,10 +521,10 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn edge_exploded_latest_time_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef,
+        e: EdgeEntryRef,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
         w: Range<EventTime>,
     ) -> Option<EventTime> {
         self.semantics
@@ -499,10 +534,10 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn edge_deletion_history<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         self.semantics
             .edge_deletion_history_window(e, view, layer_ids, self.window)
     }
@@ -510,10 +545,10 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn edge_deletion_history_rev<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         self.semantics
             .edge_deletion_history_window_rev(e, view, layer_ids, self.window)
     }
@@ -521,22 +556,22 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn edge_deletion_history_window<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         self.semantics
             .edge_deletion_history_window(e, view, layer_ids, w)
     }
 
     fn edge_deletion_history_window_rev<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId)> + Send + Sync + 'graph {
         self.semantics
             .edge_deletion_history_window_rev(e, view, layer_ids, w)
     }
@@ -544,7 +579,7 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn edge_is_valid<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
     ) -> bool {
         self.semantics
@@ -554,7 +589,7 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn edge_is_valid_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         r: Range<EventTime>,
     ) -> bool {
@@ -564,7 +599,7 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn edge_is_deleted<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
     ) -> bool {
         self.semantics
@@ -574,7 +609,7 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn edge_is_deleted_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         w: Range<EventTime>,
     ) -> bool {
@@ -584,7 +619,7 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn edge_is_active<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
     ) -> bool {
         self.semantics
@@ -594,7 +629,7 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn edge_is_active_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         w: Range<EventTime>,
     ) -> bool {
@@ -604,10 +639,10 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn edge_is_active_exploded<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
     ) -> bool {
         self.semantics
             .edge_is_active_exploded_window(e, view, t, layer, self.window.clone())
@@ -616,10 +651,10 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn edge_is_active_exploded_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
         w: Range<EventTime>,
     ) -> bool {
         self.semantics
@@ -629,10 +664,10 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn edge_is_valid_exploded<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
     ) -> bool {
         self.semantics
             .edge_is_valid_exploded_window(e, view, t, layer, self.window.clone())
@@ -641,10 +676,10 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn edge_is_valid_exploded_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
         w: Range<EventTime>,
     ) -> bool {
         self.semantics
@@ -654,10 +689,10 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn edge_exploded_deletion<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
     ) -> Option<EventTime> {
         self.semantics
             .edge_exploded_deletion_window(e, view, t, layer, self.window.clone())
@@ -666,10 +701,10 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn edge_exploded_deletion_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
         w: Range<EventTime>,
     ) -> Option<EventTime> {
         self.semantics
@@ -679,11 +714,11 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn temporal_edge_prop_exploded<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         prop_id: usize,
         t: EventTime,
-        layer_id: usize,
+        layer_id: LayerId,
     ) -> Option<Prop> {
         self.semantics
             .temporal_edge_prop_exploded(e, view, prop_id, t, layer_id)
@@ -692,10 +727,10 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn temporal_edge_prop_exploded_last_at<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         edge_time: EventTime,
-        layer_id: usize,
+        layer_id: LayerId,
         prop_id: usize,
         at: EventTime,
     ) -> Option<Prop> {
@@ -713,10 +748,10 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn temporal_edge_prop_exploded_last_at_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         edge_time: EventTime,
-        layer_id: usize,
+        layer_id: LayerId,
         prop_id: usize,
         at: EventTime,
         w: Range<EventTime>,
@@ -729,7 +764,7 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn temporal_edge_prop_last_at<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         prop_id: usize,
         t: EventTime,
@@ -741,7 +776,7 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn temporal_edge_prop_last_at_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         prop_id: usize,
         t: EventTime,
@@ -754,11 +789,11 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn temporal_edge_prop_hist<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         prop_id: usize,
-    ) -> impl Iterator<Item = (EventTime, usize, Prop)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId, Prop)> + Send + Sync + 'graph {
         self.semantics
             .temporal_edge_prop_hist_window(e, view, layer_ids, prop_id, self.window)
     }
@@ -766,11 +801,11 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn temporal_edge_prop_hist_rev<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         prop_id: usize,
-    ) -> impl Iterator<Item = (EventTime, usize, Prop)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId, Prop)> + Send + Sync + 'graph {
         self.semantics
             .temporal_edge_prop_hist_window_rev(e, view, layer_ids, prop_id, self.window)
     }
@@ -778,12 +813,12 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn temporal_edge_prop_hist_window<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         prop_id: usize,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize, Prop)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId, Prop)> + Send + Sync + 'graph {
         self.semantics
             .temporal_edge_prop_hist_window(e, view, layer_ids, prop_id, w)
     }
@@ -791,12 +826,12 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn temporal_edge_prop_hist_window_rev<'graph, G: GraphView + 'graph>(
         self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         layer_ids: &'graph LayerIds,
         prop_id: usize,
         w: Range<EventTime>,
-    ) -> impl Iterator<Item = (EventTime, usize, Prop)> + Send + Sync + 'graph {
+    ) -> impl Iterator<Item = (EventTime, LayerId, Prop)> + Send + Sync + 'graph {
         self.semantics
             .temporal_edge_prop_hist_window_rev(e, view, layer_ids, prop_id, w)
     }
@@ -804,7 +839,7 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn edge_metadata<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         prop_id: usize,
     ) -> Option<Prop> {
@@ -815,7 +850,7 @@ impl EdgeTimeSemanticsOps for WindowTimeSemantics {
     #[inline]
     fn edge_metadata_window<'graph, G: GraphView + 'graph>(
         &self,
-        e: EdgeStorageRef<'graph>,
+        e: EdgeEntryRef<'graph>,
         view: G,
         prop_id: usize,
         w: Range<EventTime>,
diff --git a/raphtory/src/db/api/view/internal/wrapped_graph.rs b/raphtory/src/db/api/view/internal/wrapped_graph.rs
index 6b7e7b64c4..afe97d45af 100644
--- a/raphtory/src/db/api/view/internal/wrapped_graph.rs
+++ b/raphtory/src/db/api/view/internal/wrapped_graph.rs
@@ -11,25 +11,3 @@ impl<T: BoxableGraphView + ?Sized> InheritStorageOps for Arc<T> {}
 impl<T: BoxableGraphView + ?Sized> InheritNodeHistoryFilter for Arc<T> {}
 
 impl<T: BoxableGraphView + ?Sized> InheritEdgeHistoryFilter for Arc<T> {}
-
-#[cfg(feature = "proto")]
-mod serialise {
-    use crate::{
-        errors::GraphError,
-        serialise::{
-            incremental::{GraphWriter, InternalCache},
-            GraphFolder,
-        },
-    };
-    use std::{ops::Deref, sync::Arc};
-
-    impl<T: InternalCache> InternalCache for Arc<T> {
-        fn init_cache(&self, path: &GraphFolder) -> Result<(), GraphError> {
-            self.deref().init_cache(path)
-        }
-
-        fn get_cache(&self) -> Option<&GraphWriter> {
-            self.deref().get_cache()
-        }
-    }
-}
diff --git a/raphtory/src/db/api/view/layer.rs b/raphtory/src/db/api/view/layer.rs
index 60cd93f821..d2812c83cc 100644
--- a/raphtory/src/db/api/view/layer.rs
+++ b/raphtory/src/db/api/view/layer.rs
@@ -37,9 +37,12 @@ pub trait LayerOps<'graph> {
 
     /// Returns the number of layers
     fn num_layers(&self) -> usize;
+
+    /// Returns exploded layer view of entity
+    fn explode_layers_iter(&self) -> impl Iterator<Item = Self::LayeredViewType> + 'graph;
 }
 
-impl<'graph, V: InternalFilter<'graph> + 'graph> LayerOps<'graph> for V {
+impl<'graph, V: InternalFilter<'graph> + 'graph + Clone> LayerOps<'graph> for V {
     type LayeredViewType = V::Filtered<LayeredGraph<V::Graph>>;
 
     fn default_layer(&self) -> Self::LayeredViewType {
@@ -97,6 +100,17 @@ impl<'graph, V: InternalFilter<'graph> + 'graph> LayerOps<'graph> for V {
     fn num_layers(&self) -> usize {
         self.base_graph().unique_layers().count()
     }
+
+    fn explode_layers_iter(&self) -> impl Iterator<Item = Self::LayeredViewType> + 'graph {
+        let all_layer_ids = self.base_graph().layer_ids();
+        let s = self.clone();
+        all_layer_ids
+            .clone()
+            .into_iter(self.base_graph().num_layers())
+            .map(move |id| {
+                s.apply_filter(LayeredGraph::new(s.base_graph().clone(), LayerIds::One(id)))
+            })
+    }
 }
 
 pub fn diff<'a>(left: &LayerIds, graph: impl GraphViewOps<'a>, other: &LayerIds) -> LayerIds {
@@ -112,7 +126,7 @@ pub fn diff<'a>(left: &LayerIds, graph: impl GraphViewOps<'a>, other: &LayerIds)
             }
         }
         (LayerIds::Multiple(ids), other) => {
-            let ids: Vec<usize> = ids.iter().filter(|id| !other.contains(id)).collect();
+            let ids: Vec<_> = ids.iter().filter(|id| !other.contains(id)).collect();
             match ids.len() {
                 0 => LayerIds::None,
                 1 => LayerIds::One(ids[0]),
@@ -120,10 +134,10 @@ pub fn diff<'a>(left: &LayerIds, graph: impl GraphViewOps<'a>, other: &LayerIds)
             }
         }
         (LayerIds::All, other) => {
-            let all_layer_ids: Vec<usize> = graph
+            let all_layer_ids: Vec<_> = graph
                 .unique_layers()
                 .map(|name| graph.get_layer_id(name.as_ref()).unwrap())
-                .filter(|id| !other.contains(id))
+                .filter(|id| !other.contains(&id))
                 .collect();
             match all_layer_ids.len() {
                 0 => LayerIds::None,
diff --git a/raphtory/src/db/graph/assertions.rs b/raphtory/src/db/graph/assertions.rs
index 808e9483a0..30b31dc1f9 100644
--- a/raphtory/src/db/graph/assertions.rs
+++ b/raphtory/src/db/graph/assertions.rs
@@ -20,17 +20,10 @@ use crate::{
     prelude::TimeOps,
 };
 use raphtory_api::core::Direction;
-#[cfg(feature = "storage")]
-use {
-    crate::db::api::storage::graph::storage_ops::disk_storage::IntoGraph,
-    raphtory_storage::disk::DiskGraphStorage, tempfile::TempDir,
-};
 
 pub enum TestGraphVariants {
     Graph,
     PersistentGraph,
-    EventDiskGraph,
-    PersistentDiskGraph,
 }
 
 impl Into<Vec<TestGraphVariants>> for TestGraphVariants {
@@ -43,8 +36,6 @@ pub enum TestVariants {
     All,
     EventOnly,
     PersistentOnly,
-    NonDiskOnly,
-    DiskOnly,
 }
 
 impl From<TestVariants> for Vec<TestGraphVariants> {
@@ -52,12 +43,10 @@ impl From<TestVariants> for Vec<TestGraphVariants> {
         use TestGraphVariants::*;
         match variants {
             TestVariants::All => {
-                vec![Graph, PersistentGraph, EventDiskGraph, PersistentDiskGraph]
+                vec![Graph, PersistentGraph]
             }
-            TestVariants::EventOnly => vec![Graph, EventDiskGraph],
-            TestVariants::PersistentOnly => vec![PersistentGraph, PersistentDiskGraph],
-            TestVariants::NonDiskOnly => vec![Graph, PersistentGraph],
-            TestVariants::DiskOnly => vec![EventDiskGraph, PersistentDiskGraph],
+            TestVariants::EventOnly => vec![Graph],
+            TestVariants::PersistentOnly => vec![PersistentGraph],
         }
     }
 }
@@ -207,6 +196,7 @@ impl<F: TryAsCompositeFilter + CreateFilter + Clone> ApplyFilter for SearchEdges
     }
 }
 
+#[track_caller]
 pub fn assert_filter_nodes_results(
     init_graph: impl FnOnce(Graph) -> Graph,
     transform: impl GraphTransformer,
@@ -283,33 +273,11 @@ pub fn assert_filter_nodes_err(
                 assert!(res.is_err(), "expected error, filter was accepted");
                 assert_filter_err_contains(res.err().unwrap(), expected);
             }
-            TestGraphVariants::EventDiskGraph => {
-                #[cfg(feature = "storage")]
-                {
-                    let tmp = TempDir::new().unwrap();
-                    let graph = graph.persist_as_disk_graph(tmp.path()).unwrap();
-                    let graph = transform.apply(graph);
-                    let res = graph.filter(filter.clone());
-                    assert!(res.is_err(), "expected error, filter was accepted");
-                    assert_filter_err_contains(res.err().unwrap(), expected);
-                }
-            }
-            TestGraphVariants::PersistentDiskGraph => {
-                #[cfg(feature = "storage")]
-                {
-                    let tmp = TempDir::new().unwrap();
-                    let disk = DiskGraphStorage::from_graph(&graph, &tmp).unwrap();
-                    let graph = disk.into_graph().persistent_graph();
-                    let graph = transform.apply(graph);
-                    let res = graph.filter(filter.clone());
-                    assert!(res.is_err(), "expected error, filter was accepted");
-                    assert_filter_err_contains(res.err().unwrap(), expected);
-                }
-            }
         }
     }
 }
 
+#[track_caller]
 pub fn assert_filter_neighbours_results(
     init_graph: impl FnOnce(Graph) -> Graph,
     transform: impl GraphTransformer,
@@ -329,6 +297,7 @@ pub fn assert_filter_neighbours_results(
     )
 }
 
+#[track_caller]
 pub fn assert_search_nodes_results(
     init_graph: impl FnOnce(Graph) -> Graph,
     transform: impl GraphTransformer,
@@ -349,6 +318,7 @@ pub fn assert_search_nodes_results(
     }
 }
 
+#[track_caller]
 pub fn assert_filter_edges_results(
     init_graph: impl FnOnce(Graph) -> Graph,
     transform: impl GraphTransformer,
@@ -366,6 +336,7 @@ pub fn assert_filter_edges_results(
     )
 }
 
+#[track_caller]
 pub fn assert_select_edges_results(
     init_graph: impl FnOnce(Graph) -> Graph,
     transform: impl GraphTransformer,
@@ -383,6 +354,7 @@ pub fn assert_select_edges_results(
     )
 }
 
+#[track_caller]
 pub fn assert_search_edges_results(
     init_graph: impl FnOnce(Graph) -> Graph,
     transform: impl GraphTransformer,
@@ -403,6 +375,7 @@ pub fn assert_search_edges_results(
     }
 }
 
+#[track_caller]
 fn assert_results(
     init_graph: impl FnOnce(Graph) -> Graph,
     pre_transform: impl Fn(&Graph) -> (),
@@ -440,30 +413,6 @@ fn assert_results(
                 let result = sorted(apply.apply(graph));
                 assert_eq!(expected, result);
             }
-            TestGraphVariants::EventDiskGraph => {
-                #[cfg(feature = "storage")]
-                {
-                    let tmp = TempDir::new().unwrap();
-                    let graph = graph.persist_as_disk_graph(tmp.path()).unwrap();
-                    pre_transform(&graph);
-                    let graph = transform.apply(graph);
-                    let result = sorted(apply.apply(graph));
-                    assert_eq!(expected, result);
-                }
-            }
-            TestGraphVariants::PersistentDiskGraph => {
-                #[cfg(feature = "storage")]
-                {
-                    let tmp = TempDir::new().unwrap();
-                    let graph = DiskGraphStorage::from_graph(&graph, &tmp).unwrap();
-                    let graph = graph.into_graph();
-                    pre_transform(&graph);
-                    let graph = graph.persistent_graph();
-                    let graph = transform.apply(graph);
-                    let result = sorted(apply.apply(graph));
-                    assert_eq!(expected, result);
-                }
-            }
         }
     }
 }
diff --git a/raphtory/src/db/graph/edge.rs b/raphtory/src/db/graph/edge.rs
index 8c6aaf0c5d..e77ceae9bf 100644
--- a/raphtory/src/db/graph/edge.rs
+++ b/raphtory/src/db/graph/edge.rs
@@ -1,6 +1,6 @@
 //! Defines the `Edge` struct, which represents an edge in the graph.
 //!
-//! Edges are used to define directed connections between verticies in the graph.
+//! Edges are used to define directed connections between vertices in the graph.
 //! Edges are identified by a unique ID, can have a direction (Ingoing, Outgoing, or Both)
 //! and can have properties associated with them.
 //!
@@ -11,7 +11,7 @@ use crate::{
     },
     db::{
         api::{
-            mutation::{time_from_input, CollectProperties},
+            mutation::{time_from_input, time_from_input_session},
             properties::{
                 internal::{
                     InternalMetadataOps, InternalTemporalPropertiesOps,
@@ -32,15 +32,19 @@ use crate::{
 };
 use itertools::Itertools;
 use raphtory_api::core::{
-    entities::properties::prop::PropType,
+    entities::{properties::prop::PropType, LayerId},
     storage::{arc_str::ArcStr, timeindex::EventTime},
     utils::time::TryIntoInputTime,
 };
-use raphtory_core::entities::graph::tgraph::InvalidLayer;
+use raphtory_core::entities::{
+    graph::tgraph::InvalidLayer,
+    nodes::node_ref::{AsNodeRef, NodeRef},
+};
 use raphtory_storage::{
+    durability_ops::DurabilityOps,
     graph::edges::edge_storage_ops::EdgeStorageOps,
     mutation::{
-        addition_ops::InternalAdditionOps, deletion_ops::InternalDeletionOps,
+        addition_ops::{EdgeWriteLock, InternalAdditionOps},
         property_addition_ops::InternalPropertyAdditionOps,
     },
 };
@@ -51,6 +55,7 @@ use std::{
     iter,
     sync::Arc,
 };
+use storage::wal::{GraphWalOps, WalOps};
 
 /// A view of an edge in the graph.
 #[derive(Copy, Clone)]
@@ -108,7 +113,7 @@ impl<G: GraphView> EdgeView<G> {
         Self { graph, edge }
     }
 
-    pub fn deletions_hist(&self) -> BoxedLIter<'_, (EventTime, usize)> {
+    pub fn deletions_hist(&self) -> BoxedLIter<'_, (EventTime, LayerId)> {
         let g = &self.graph;
         let e = self.edge;
         if edge_valid_layer(g, e) {
@@ -154,15 +159,50 @@ impl<G: GraphView> EdgeView<G> {
 impl<
         G: StaticGraphViewOps
             + InternalAdditionOps<Error = GraphError>
-            + InternalPropertyAdditionOps<Error = GraphError>
-            + InternalDeletionOps<Error = GraphError>,
+            + InternalPropertyAdditionOps<Error = GraphError>,
     > EdgeView<G>
 {
     pub fn delete<T: TryIntoInputTime>(&self, t: T, layer: Option<&str>) -> Result<(), GraphError> {
+        let transaction_manager = self.graph.core_graph().transaction_manager()?;
+        let wal = self.graph.core_graph().wal()?;
+        let transaction_id = transaction_manager.begin_transaction();
+        let src = self.src();
+        let dst = self.dst();
+        let edge_id = self.edge.pid();
+
+        let layer_id = self.resolve_layer(layer, true)?;
         let t = time_from_input(&self.graph, t)?;
-        let layer = self.resolve_layer(layer, true)?;
-        self.graph
-            .internal_delete_existing_edge(t, self.edge.pid(), layer)?;
+
+        let mut writer = self
+            .graph
+            .atomic_add_edge(src.as_node_ref(), dst.as_node_ref(), None)
+            .map_err(into_graph_err)?;
+
+        let src_name = None;
+        let dst_name = None;
+
+        let lsn = wal.log_delete_edge(
+            transaction_id,
+            t,
+            src_name,
+            src.node,
+            dst_name,
+            dst.node,
+            edge_id,
+            layer,
+            layer_id,
+        )?;
+
+        writer.internal_delete_edge(t, layer_id);
+
+        writer.set_lsn(lsn);
+        transaction_manager.end_transaction(transaction_id);
+        drop(writer);
+
+        if let Err(e) = wal.flush(lsn) {
+            return Err(GraphError::FatalWriteError(e));
+        }
+
         Ok(())
     }
 }
@@ -245,7 +285,7 @@ impl<'graph, G: GraphViewOps<'graph>> BaseEdgeViewOps<'graph> for EdgeView<G> {
 }
 
 impl<G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps> EdgeView<G> {
-    fn resolve_layer(&self, layer: Option<&str>, create: bool) -> Result<usize, GraphError> {
+    fn resolve_layer(&self, layer: Option<&str>, create: bool) -> Result<LayerId, GraphError> {
         let layer_id = match layer {
             Some(name) => match self.edge.layer() {
                 Some(l_id) => self
@@ -288,6 +328,28 @@ impl<G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps> EdgeView<G> {
         Ok(layer_id)
     }
 
+    fn resolve_and_check_layer_for_metadata(
+        &self,
+        layer: Option<&str>,
+    ) -> Result<LayerId, GraphError> {
+        let create = false;
+        let layer_id = self.resolve_layer(layer, create)?;
+
+        if self
+            .graph
+            .core_edge(self.edge.pid())
+            .has_layer(&LayerIds::One(layer_id))
+        {
+            Ok(layer_id)
+        } else {
+            Err(GraphError::InvalidEdgeLayer {
+                layer: layer.unwrap_or("_default").to_string(),
+                src: self.src().name(),
+                dst: self.dst().name(),
+            })
+        }
+    }
+
     /// Add metadata for the edge
     ///
     /// # Arguments
@@ -302,76 +364,170 @@ impl<G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps> EdgeView<G> {
     /// Returns:
     ///     Ok(()) if metadata added successfully.
     ///     Err(GraphError) if the operation fails.
-    pub fn add_metadata<C: CollectProperties>(
+    pub fn add_metadata<PN: AsRef<str>, P: Into<Prop>>(
         &self,
-        properties: C,
+        properties: impl IntoIterator<Item = (PN, P)>,
         layer: Option<&str>,
     ) -> Result<(), GraphError> {
-        let input_layer_id = self.resolve_layer(layer, false)?;
-        if !self
-            .graph
-            .core_edge(self.edge.pid())
-            .has_layer(&LayerIds::One(input_layer_id))
-        {
-            return Err(GraphError::InvalidEdgeLayer {
-                layer: layer.unwrap_or("_default").to_string(),
-                src: self.src().name(),
-                dst: self.dst().name(),
-            });
-        }
-        let properties: Vec<(usize, Prop)> = properties.collect_properties(|name, dtype| {
-            Ok(self
-                .graph
-                .resolve_edge_property(name, dtype, true)
-                .map_err(into_graph_err)?
-                .inner())
-        })?;
+        let is_update = false;
+        self.add_metadata_impl(properties, layer, is_update)
+    }
 
-        self.graph
-            .internal_add_edge_metadata(self.edge.pid(), input_layer_id, &properties)
-            .map_err(into_graph_err)?;
-        Ok(())
+    pub fn update_metadata<PN: AsRef<str>, P: Into<Prop>>(
+        &self,
+        props: impl IntoIterator<Item = (PN, P)>,
+        layer: Option<&str>,
+    ) -> Result<(), GraphError> {
+        let is_update = true;
+        self.add_metadata_impl(props, layer, is_update)
     }
 
-    pub fn update_metadata<C: CollectProperties>(
+    /// Adds metadata properties to the edge.
+    ///
+    /// When `is_update` is true, existing properties are updated, otherwise
+    /// an error is returned if the property already exists.
+    fn add_metadata_impl<PN: AsRef<str>, P: Into<Prop>>(
         &self,
-        props: C,
+        properties: impl IntoIterator<Item = (PN, P)>,
         layer: Option<&str>,
+        is_update: bool,
     ) -> Result<(), GraphError> {
-        let input_layer_id = self.resolve_layer(layer, false).map_err(into_graph_err)?;
-        let properties: Vec<(usize, Prop)> = props.collect_properties(|name, dtype| {
-            Ok(self
-                .graph
-                .resolve_edge_property(name, dtype, true)
+        let input_layer_id = self.resolve_and_check_layer_for_metadata(layer)?;
+        let transaction_manager = self.graph.core_graph().transaction_manager()?;
+        let wal = self.graph.core_graph().wal()?;
+        let transaction_id = transaction_manager.begin_transaction();
+
+        let props_with_status = self.graph.core_graph().validate_props_with_status(
+            true,
+            self.graph.edge_meta(),
+            properties.into_iter().map(|(n, p)| (n, p.into())),
+        )?;
+
+        let props = props_with_status
+            .iter()
+            .map(|maybe_new| {
+                let (_, prop_id, prop) = maybe_new.as_ref().inner();
+                (*prop_id, prop.clone())
+            })
+            .collect::<Vec<_>>();
+
+        let eid = self.edge.pid();
+
+        let mut writer = if is_update {
+            self.graph
+                .internal_update_edge_metadata(eid, input_layer_id, props)
                 .map_err(into_graph_err)?
-                .inner())
-        })?;
+        } else {
+            self.graph
+                .internal_add_edge_metadata(eid, input_layer_id, props)
+                .map_err(into_graph_err)?
+        };
+
+        let props_for_wal = props_with_status
+            .iter()
+            .map(|maybe_new| {
+                let (prop_name, prop_id, prop) = maybe_new.as_ref().inner();
+                (prop_name.as_ref(), *prop_id, prop.clone())
+            })
+            .collect::<Vec<_>>();
+
+        let lsn = wal.log_add_edge_metadata(transaction_id, eid, input_layer_id, props_for_wal)?;
+
+        writer.set_lsn(lsn);
+        transaction_manager.end_transaction(transaction_id);
+        drop(writer);
+
+        if let Err(e) = wal.flush(lsn) {
+            return Err(GraphError::FatalWriteError(e));
+        }
 
-        self.graph
-            .internal_update_edge_metadata(self.edge.pid(), input_layer_id, &properties)
-            .map_err(into_graph_err)?;
         Ok(())
     }
 
-    pub fn add_updates<C: CollectProperties, T: TryIntoInputTime>(
+    pub fn add_updates<
+        T: TryIntoInputTime,
+        PN: AsRef<str>,
+        PI: Into<Prop>,
+        PII: IntoIterator<Item = (PN, PI)>,
+    >(
         &self,
         time: T,
-        props: C,
+        props: PII,
         layer: Option<&str>,
     ) -> Result<(), GraphError> {
-        let t = time_from_input(&self.graph, time)?;
+        let transaction_manager = self.graph.core_graph().transaction_manager()?;
+        let wal = self.graph.core_graph().wal()?;
+        let transaction_id = transaction_manager.begin_transaction();
+        let session = self.graph.write_session().map_err(|err| err.into())?;
+
+        let t = time_from_input_session(&session, time)?;
         let layer_id = self.resolve_layer(layer, true)?;
-        let properties: Vec<(usize, Prop)> = props.collect_properties(|name, dtype| {
-            Ok(self
-                .graph
-                .resolve_edge_property(name, dtype, false)
-                .map_err(into_graph_err)?
-                .inner())
-        })?;
 
-        self.graph
-            .internal_add_edge_update(t, self.edge.pid(), &properties, layer_id)
+        let props_with_status = self
+            .graph
+            .validate_props_with_status(
+                false,
+                self.graph.edge_meta(),
+                props.into_iter().map(|(k, v)| (k, v.into())),
+            )
+            .map_err(into_graph_err)?;
+
+        let src = self.src().node;
+        let src_name = None;
+        let dst = self.dst().node;
+        let dst_name = None;
+        let edge_id = self.edge.pid();
+
+        let mut writer = self
+            .graph
+            .atomic_add_edge(
+                NodeRef::Internal(src),
+                NodeRef::Internal(dst),
+                Some(edge_id),
+            )
+            .map_err(into_graph_err)?;
+
+        let props_for_wal = props_with_status
+            .iter()
+            .map(|maybe_new| {
+                let (prop_name, prop_id, prop) = maybe_new.as_ref().inner();
+                (prop_name.as_ref(), *prop_id, prop.clone())
+            })
+            .collect::<Vec<_>>();
+
+        let lsn = wal
+            .log_add_edge(
+                transaction_id,
+                t,
+                src_name,
+                src,
+                dst_name,
+                dst,
+                edge_id,
+                layer,
+                layer_id,
+                props_for_wal,
+            )
             .map_err(into_graph_err)?;
+
+        let props = props_with_status
+            .into_iter()
+            .map(|maybe_new| {
+                let (_, prop_id, prop) = maybe_new.inner();
+                (prop_id, prop)
+            })
+            .collect::<Vec<_>>();
+
+        writer.internal_add_update(t, layer_id, props);
+
+        writer.set_lsn(lsn);
+        transaction_manager.end_transaction(transaction_id);
+        drop(writer);
+
+        if let Err(e) = wal.flush(lsn) {
+            return Err(GraphError::FatalWriteError(e));
+        }
+
         Ok(())
     }
 }
@@ -390,12 +546,20 @@ impl<'graph, G: GraphViewOps<'graph>> InternalMetadataOps for EdgeView<G> {
     }
 
     fn metadata_ids(&self) -> BoxedLIter<'_, usize> {
-        Box::new(0..self.graph.edge_meta().metadata_mapper().len())
+        self.graph
+            .edge_meta()
+            .metadata_mapper()
+            .ids()
+            .into_dyn_boxed()
     }
 
     fn metadata_keys(&self) -> BoxedLIter<'_, ArcStr> {
-        let reverse_map = self.graph.edge_meta().metadata_mapper().get_keys();
-        Box::new(self.metadata_ids().map(move |id| reverse_map[id].clone()))
+        self.graph
+            .edge_meta()
+            .metadata_mapper()
+            .keys()
+            .into_iter()
+            .into_dyn_boxed()
     }
 
     fn get_metadata(&self, id: usize) -> Option<Prop> {
@@ -600,15 +764,20 @@ impl<'graph, G: GraphViewOps<'graph>> InternalTemporalPropertiesOps for EdgeView
     }
 
     fn temporal_prop_ids(&self) -> BoxedLIter<'_, usize> {
-        Box::new(0..self.graph.edge_meta().temporal_prop_mapper().len())
+        self.graph
+            .edge_meta()
+            .temporal_prop_mapper()
+            .ids()
+            .into_dyn_boxed()
     }
 
     fn temporal_prop_keys(&self) -> BoxedLIter<'_, ArcStr> {
-        let reverse_map = self.graph.edge_meta().temporal_prop_mapper().get_keys();
-        Box::new(
-            self.temporal_prop_ids()
-                .map(move |id| reverse_map[id].clone()),
-        )
+        self.graph
+            .edge_meta()
+            .temporal_prop_mapper()
+            .keys()
+            .into_iter()
+            .into_dyn_boxed()
     }
 }
 
diff --git a/raphtory/src/db/graph/graph.rs b/raphtory/src/db/graph/graph.rs
index 73f5374471..9ae43bf657 100644
--- a/raphtory/src/db/graph/graph.rs
+++ b/raphtory/src/db/graph/graph.rs
@@ -9,18 +9,20 @@
 //! ```rust
 //! use raphtory::prelude::*;
 //! let graph = Graph::new();
-//! graph.add_node(0, "Alice", NO_PROPS, None).unwrap();
-//! graph.add_node(1, "Bob", NO_PROPS, None).unwrap();
+//! graph.add_node(0, "Alice", NO_PROPS, None, None).unwrap();
+//! graph.add_node(1, "Bob", NO_PROPS, None, None).unwrap();
 //! graph.add_edge(2, "Alice", "Bob", NO_PROPS, None).unwrap();
 //! graph.count_edges();
 //! ```
 //!
 use super::views::deletion_graph::PersistentGraph;
+#[cfg(feature = "io")]
+use crate::serialise::GraphPaths;
 use crate::{
     db::{
         api::{
             state::ops::NodeFilterOp,
-            storage::storage::Storage,
+            storage::storage::{Config, PersistenceStrategy, Storage},
             view::{
                 internal::{
                     GraphView, InheritEdgeHistoryFilter, InheritNodeHistoryFilter,
@@ -31,6 +33,7 @@ use crate::{
         },
         graph::{edges::Edges, node::NodeView, nodes::Nodes},
     },
+    errors::GraphError,
     prelude::*,
 };
 use raphtory_api::{
@@ -42,7 +45,6 @@ use raphtory_storage::{
     mutation::InheritMutationOps,
 };
 use rayon::prelude::*;
-use serde::{Deserialize, Serialize};
 use std::{
     collections::{BTreeMap, HashMap, HashSet},
     fmt::{Display, Formatter},
@@ -50,15 +52,14 @@ use std::{
     ops::Deref,
     sync::Arc,
 };
+use storage::Extension;
 
 #[repr(transparent)]
-#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+#[derive(Debug, Clone, Default)]
 pub struct Graph {
     pub(crate) inner: Arc<Storage>,
 }
 
-impl InheritCoreGraphOps for Graph {}
-impl InheritLayerOps for Graph {}
 impl From<Arc<Storage>> for Graph {
     fn from(inner: Arc<Storage>) -> Self {
         Self { inner }
@@ -73,8 +74,196 @@ impl From<GraphStorage> for Graph {
     }
 }
 
+impl Base for Graph {
+    type Base = Storage;
+
+    #[inline(always)]
+    fn base(&self) -> &Self::Base {
+        &self.inner
+    }
+}
+
+impl InheritMutationOps for Graph {}
+
+impl InheritViewOps for Graph {}
+
+impl InheritStorageOps for Graph {}
+
+impl InheritNodeHistoryFilter for Graph {}
+
+impl InheritEdgeHistoryFilter for Graph {}
+
+impl InheritCoreGraphOps for Graph {}
+
+impl InheritLayerOps for Graph {}
+
 impl Static for Graph {}
 
+impl Display for Graph {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.inner)
+    }
+}
+
+impl<'graph, G: GraphViewOps<'graph>> PartialEq<G> for Graph
+where
+    Self: 'graph,
+{
+    fn eq(&self, other: &G) -> bool {
+        graph_equal(self, other)
+    }
+}
+
+impl Graph {
+    /// Create a new graph
+    ///
+    /// Returns:
+    ///
+    /// A raphtory graph
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use raphtory::prelude::Graph;
+    /// let g = Graph::new();
+    /// ```
+    pub fn new() -> Self {
+        Self {
+            inner: Arc::new(Storage::default()),
+        }
+    }
+
+    /// Create a new graph with config
+    ///
+    /// Returns:
+    ///
+    /// A raphtory graph
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use raphtory::prelude::*;
+    ///
+    /// let g = Graph::new_with_config(Config::default().with_max_node_page_len(262144)).unwrap();
+    /// ```
+    pub fn new_with_config(config: Config) -> Result<Self, GraphError> {
+        Ok(Self {
+            inner: Arc::new(Storage::new_with_config(config)?),
+        })
+    }
+
+    /// Create a new graph at a specific path
+    ///
+    /// # Arguments
+    /// * `path` - The path to the storage location
+    /// # Returns
+    /// A raphtory graph with storage at the specified path
+    /// # Example
+    /// ```no_run
+    /// use raphtory::prelude::Graph;
+    /// let g = Graph::new_at_path("/path/to/storage");
+    /// ```
+    #[cfg(feature = "io")]
+    pub fn new_at_path(path: &(impl GraphPaths + ?Sized)) -> Result<Self, GraphError> {
+        if !Extension::disk_storage_enabled() {
+            return Err(GraphError::DiskGraphNotEnabled);
+        }
+
+        path.init()?;
+        let graph_storage_path = path.graph_path()?;
+        let storage = Storage::new_at_path(graph_storage_path)?;
+
+        let graph = Self {
+            inner: Arc::new(storage),
+        };
+
+        path.write_metadata(&graph)?;
+        Ok(graph)
+    }
+
+    #[cfg(feature = "io")]
+    pub fn new_at_path_with_config(
+        path: &(impl GraphPaths + ?Sized),
+        config: Config,
+    ) -> Result<Self, GraphError> {
+        if !Extension::disk_storage_enabled() {
+            return Err(GraphError::DiskGraphNotEnabled);
+        }
+
+        path.init()?;
+
+        let graph = Self {
+            inner: Arc::new(Storage::new_at_path_with_config(
+                path.graph_path()?,
+                config,
+            )?),
+        };
+
+        path.write_metadata(&graph)?;
+        Ok(graph)
+    }
+
+    /// Load a graph from a specific path
+    /// # Arguments
+    /// * `path` - The path to the storage location
+    /// # Returns
+    /// A raphtory graph loaded from the specified path
+    /// # Example
+    /// ```no_run
+    /// use raphtory::prelude::Graph;
+    /// let g = Graph::load("/path/to/storage");
+    #[cfg(feature = "io")]
+    pub fn load(path: &(impl GraphPaths + ?Sized)) -> Result<Self, GraphError> {
+        // TODO: add support for loading indexes and vectors
+        Ok(Self {
+            inner: Arc::new(Storage::load(path.graph_path()?)?),
+        })
+    }
+
+    /// Load a graph from a specific path, overriding config
+    /// # Arguments
+    /// * `path` - The path to the storage location
+    /// * `config` - The new config (note that it is not possible to change the page sizes)
+    /// # Returns
+    /// A raphtory graph loaded from the specified path
+    /// # Example
+    /// ```no_run
+    /// use raphtory::prelude::Graph;
+    /// let g = Graph::load("/path/to/storage");
+    #[cfg(feature = "io")]
+    pub fn load_with_config(
+        path: &(impl GraphPaths + ?Sized),
+        config: Config,
+    ) -> Result<Self, GraphError> {
+        // TODO: add support for loading indexes and vectors
+        Ok(Self {
+            inner: Arc::new(Storage::load_with_config(path.graph_path()?, config)?),
+        })
+    }
+
+    pub(crate) fn from_storage(inner: Arc<Storage>) -> Self {
+        Self { inner }
+    }
+
+    pub(crate) fn from_internal_graph(graph_storage: GraphStorage) -> Self {
+        let inner = Arc::new(Storage::from_inner(graph_storage));
+        Self { inner }
+    }
+
+    pub fn event_graph(&self) -> Graph {
+        self.clone()
+    }
+
+    /// Get persistent graph
+    pub fn persistent_graph(&self) -> PersistentGraph {
+        PersistentGraph::from_storage(self.inner.clone())
+    }
+}
+
+// ###########################################
+// Methods for checking equality of graphs
+// ###########################################
+
 pub fn graph_equal<'graph1, 'graph2, G1: GraphViewOps<'graph1>, G2: GraphViewOps<'graph2>>(
     g1: &G1,
     g2: &G2,
@@ -113,6 +302,7 @@ fn normalise_temporal_map<T: AsTime + Copy>(
     out
 }
 
+#[track_caller]
 pub fn assert_node_equal<'graph, G1: GraphViewOps<'graph>, G2: GraphViewOps<'graph>>(
     n1: NodeView<'graph, G1>,
     n2: NodeView<'graph, G2>,
@@ -120,6 +310,7 @@ pub fn assert_node_equal<'graph, G1: GraphViewOps<'graph>, G2: GraphViewOps<'gra
     assert_node_equal_layer(n1, n2, "", false, false)
 }
 
+#[track_caller]
 pub fn assert_node_equal_layer<'graph, G1: GraphView + 'graph, G2: GraphView + 'graph>(
     n1: NodeView<'graph, G1>,
     n2: NodeView<'graph, G2>,
@@ -325,6 +516,7 @@ pub fn assert_node_equal_layer<'graph, G1: GraphView + 'graph, G2: GraphView + '
     }
 }
 
+#[track_caller]
 pub fn assert_nodes_equal<
     'graph,
     G1: GraphViewOps<'graph>,
@@ -340,6 +532,7 @@ pub fn assert_nodes_equal<
     assert_nodes_equal_layer(nodes1, nodes2, "", false, false);
 }
 
+#[track_caller]
 pub fn assert_nodes_equal_layer<
     'graph,
     G1: GraphViewOps<'graph>,
@@ -356,19 +549,23 @@ pub fn assert_nodes_equal_layer<
     only_timestamps: bool,
 ) {
     let mut nodes1: Vec<_> = nodes1.collect();
-    nodes1.sort();
     let mut nodes2: Vec<_> = nodes2.collect();
+
+    nodes1.sort();
     nodes2.sort();
+
     assert_eq!(
         nodes1.len(),
         nodes2.len(),
         "mismatched number of nodes{layer_tag}",
     );
+
     for (n1, n2) in nodes1.into_iter().zip(nodes2) {
         assert_node_equal_layer(n1, n2, layer_tag, persistent, only_timestamps);
     }
 }
 
+#[track_caller]
 pub fn assert_edges_equal<
     'graph1,
     'graph2,
@@ -381,6 +578,7 @@ pub fn assert_edges_equal<
     assert_edges_equal_layer(edges1, edges2, "", false, false);
 }
 
+#[track_caller]
 pub fn assert_edges_equal_layer<
     'graph1,
     'graph2,
@@ -546,6 +744,7 @@ pub fn assert_edges_equal_layer<
     }
 }
 
+#[track_caller]
 fn assert_graph_equal_layer<'graph, G1: GraphViewOps<'graph>, G2: GraphViewOps<'graph>>(
     g1: &G1,
     g2: &G2,
@@ -626,6 +825,7 @@ fn assert_graph_equal_layer<'graph, G1: GraphViewOps<'graph>, G2: GraphViewOps<'
     );
 }
 
+#[track_caller]
 fn assert_graph_equal_inner<'graph, G1: GraphViewOps<'graph>, G2: GraphViewOps<'graph>>(
     g1: &G1,
     g2: &G2,
@@ -634,8 +834,10 @@ fn assert_graph_equal_inner<'graph, G1: GraphViewOps<'graph>, G2: GraphViewOps<'
 ) {
     black_box({
         assert_graph_equal_layer(g1, g2, None, persistent, only_timestamps);
+
         let left_layers: HashSet<_> = g1.unique_layers().collect();
         let right_layers: HashSet<_> = g2.unique_layers().collect();
+
         assert_eq!(
             left_layers, right_layers,
             "mismatched layers: left {:?}, right {:?}",
@@ -656,6 +858,7 @@ fn assert_graph_equal_inner<'graph, G1: GraphViewOps<'graph>, G2: GraphViewOps<'
     })
 }
 
+#[track_caller]
 pub fn assert_graph_equal<'graph, G1: GraphViewOps<'graph>, G2: GraphViewOps<'graph>>(
     g1: &G1,
     g2: &G2,
@@ -670,7 +873,9 @@ pub fn assert_graph_equal_timestamps<'graph, G1: GraphViewOps<'graph>, G2: Graph
     assert_graph_equal_inner(g1, g2, false, true)
 }
 
-/// Equality check for materialized persistent graph that ignores the updates generated by the materialise at graph.earliest_time()
+/// Equality check for materialized persistent graph that ignores the
+/// updates generated by the materialise at graph.earliest_time().
+#[track_caller]
 pub fn assert_persistent_materialize_graph_equal<
     'graph,
     G1: GraphViewOps<'graph>,
@@ -681,86 +886,3 @@ pub fn assert_persistent_materialize_graph_equal<
 ) {
     assert_graph_equal_inner(g1, g2, true, false)
 }
-
-impl Display for Graph {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.inner)
-    }
-}
-
-impl<'graph, G: GraphViewOps<'graph>> PartialEq<G> for Graph
-where
-    Self: 'graph,
-{
-    fn eq(&self, other: &G) -> bool {
-        graph_equal(self, other)
-    }
-}
-
-impl Base for Graph {
-    type Base = Storage;
-
-    #[inline(always)]
-    fn base(&self) -> &Self::Base {
-        &self.inner
-    }
-}
-
-impl InheritMutationOps for Graph {}
-
-impl InheritViewOps for Graph {}
-
-impl InheritStorageOps for Graph {}
-
-impl InheritNodeHistoryFilter for Graph {}
-
-impl InheritEdgeHistoryFilter for Graph {}
-
-impl Graph {
-    /// Create a new graph
-    ///
-    /// Returns:
-    ///
-    /// A raphtory graph
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// use raphtory::prelude::Graph;
-    /// let g = Graph::new();
-    /// ```
-    pub fn new() -> Self {
-        Self {
-            inner: Arc::new(Storage::default()),
-        }
-    }
-
-    /// Create a new graph with specified number of shards
-    ///
-    /// Returns:
-    ///
-    /// A raphtory graph
-    pub fn new_with_shards(num_shards: usize) -> Self {
-        Self {
-            inner: Arc::new(Storage::new(num_shards)),
-        }
-    }
-
-    pub(crate) fn from_storage(inner: Arc<Storage>) -> Self {
-        Self { inner }
-    }
-
-    pub(crate) fn from_internal_graph(graph_storage: GraphStorage) -> Self {
-        let inner = Arc::new(Storage::from_inner(graph_storage));
-        Self { inner }
-    }
-
-    pub fn event_graph(&self) -> Graph {
-        self.clone()
-    }
-
-    /// Get persistent graph
-    pub fn persistent_graph(&self) -> PersistentGraph {
-        PersistentGraph::from_storage(self.inner.clone())
-    }
-}
diff --git a/raphtory/src/db/graph/mod.rs b/raphtory/src/db/graph/mod.rs
index 6d19a7eb3e..8d393764e3 100644
--- a/raphtory/src/db/graph/mod.rs
+++ b/raphtory/src/db/graph/mod.rs
@@ -14,13 +14,12 @@ pub(crate) fn create_node_type_filter<I: IntoIterator<Item = V>, V: AsRef<str>>(
     dict_mapper: &DictMapper,
     node_types: I,
 ) -> Arc<[bool]> {
-    let len = dict_mapper.len();
-    let mut bool_arr = vec![false; len];
+    let mut bool_arr = vec![false; dict_mapper.num_all_fields()];
 
     for nt in node_types {
         let nt = nt.as_ref();
         if nt.is_empty() {
-            bool_arr[0] = true;
+            bool_arr[0] = true; // FIXME: "" treated as default?
         } else if let Some(id) = dict_mapper.get_id(nt) {
             bool_arr[id] = true;
         }
diff --git a/raphtory/src/db/graph/node.rs b/raphtory/src/db/graph/node.rs
index fdbb271e7e..087d4ee53a 100644
--- a/raphtory/src/db/graph/node.rs
+++ b/raphtory/src/db/graph/node.rs
@@ -10,7 +10,7 @@ use crate::{
     },
     db::{
         api::{
-            mutation::{time_from_input, CollectProperties},
+            mutation::time_from_input_session,
             properties::internal::{
                 InternalMetadataOps, InternalTemporalPropertiesOps, InternalTemporalPropertyViewOps,
             },
@@ -29,18 +29,29 @@ use crate::{
     prelude::*,
 };
 use raphtory_api::core::{
-    entities::properties::prop::PropType,
+    entities::{
+        properties::{meta::STATIC_GRAPH_LAYER_ID, prop::PropType},
+        LayerId, ELID,
+    },
     storage::{arc_str::ArcStr, timeindex::EventTime},
     utils::time::TryIntoInputTime,
 };
-use raphtory_core::entities::ELID;
-use raphtory_storage::{core_ops::CoreGraphOps, graph::graph::GraphStorage};
+use raphtory_storage::{
+    core_ops::CoreGraphOps,
+    durability_ops::DurabilityOps,
+    graph::graph::GraphStorage,
+    mutation::{
+        addition_ops::{InternalAdditionOps, NodeWriteLock},
+        MutationError,
+    },
+};
 use std::{
     fmt,
     hash::{Hash, Hasher},
     marker::PhantomData,
     sync::Arc,
 };
+use storage::wal::{GraphWalOps, WalOps};
 
 /// View of a Node in a Graph
 #[derive(Copy, Clone)]
@@ -151,7 +162,7 @@ impl<'graph, G: GraphViewOps<'graph>> NodeView<'graph, G> {
         let node = self.graph.core_node(self.node);
         GenLockedIter::from(node, move |node| {
             semantics
-                .node_edge_history(node.as_ref(), &self.graph)
+                .node_edge_history(node.as_ref(), &self.graph, self.graph.layer_ids())
                 .into_dyn_boxed()
         })
     }
@@ -161,7 +172,7 @@ impl<'graph, G: GraphViewOps<'graph>> NodeView<'graph, G> {
         let node = self.graph.core_node(self.node);
         GenLockedIter::from(node, move |node| {
             semantics
-                .node_edge_history_rev(node.as_ref(), &self.graph)
+                .node_edge_history_rev(node.as_ref(), &self.graph, self.graph.layer_ids())
                 .into_dyn_boxed()
         })
     }
@@ -224,7 +235,11 @@ impl<'graph, G: CoreGraphOps + GraphTimeSemanticsOps> InternalTemporalProperties
     }
 
     fn temporal_prop_ids(&self) -> BoxedLIter<'_, usize> {
-        Box::new(0..self.graph.node_meta().temporal_prop_mapper().len())
+        self.graph
+            .node_meta()
+            .temporal_prop_mapper()
+            .ids()
+            .into_dyn_boxed()
     }
 }
 
@@ -241,8 +256,8 @@ impl<'graph, G: GraphViewOps<'graph>> InternalTemporalPropertyViewOps for NodeVi
         let semantics = self.graph.node_time_semantics();
         let node = self.graph.core_node(self.node);
         let res = semantics
-            .node_tprop_iter(node.as_ref(), &self.graph, id)
-            .next_back()
+            .node_tprop_iter_rev(node.as_ref(), &self.graph, id)
+            .next()
             .map(|(_, v)| v);
         res
     }
@@ -263,8 +278,7 @@ impl<'graph, G: GraphViewOps<'graph>> InternalTemporalPropertyViewOps for NodeVi
         let node = self.graph.core_node(self.node);
         GenLockedIter::from(node, |node| {
             semantics
-                .node_tprop_iter(node.as_ref(), &self.graph, id)
-                .rev()
+                .node_tprop_iter_rev(node.as_ref(), &self.graph, id)
                 .into_dyn_boxed()
         })
         .into_dyn_boxed()
@@ -280,7 +294,7 @@ impl<'graph, G: GraphViewOps<'graph>> InternalTemporalPropertyViewOps for NodeVi
 }
 
 impl<'graph, G: GraphView + 'graph> NodeView<'graph, G> {
-    pub fn rows<'a>(&'a self) -> BoxedLIter<'a, (EventTime, Vec<(usize, Prop)>)>
+    pub fn rows<'a>(&'a self) -> BoxedLIter<'a, (EventTime, LayerId, Vec<(usize, Prop)>)>
     where
         'graph: 'a,
     {
@@ -310,8 +324,11 @@ impl<'graph, G: CoreGraphOps> InternalMetadataOps for NodeView<'graph, G> {
     }
 
     fn metadata_ids(&self) -> BoxedLIter<'_, usize> {
-        Box::new(0..self.graph.node_meta().metadata_mapper().len())
-        // self.graph.node_metadata_ids(self.node)
+        self.graph
+            .node_meta()
+            .metadata_mapper()
+            .ids()
+            .into_dyn_boxed()
     }
 
     fn get_metadata(&self, id: usize) -> Option<Prop> {
@@ -377,56 +394,219 @@ impl<'graph, G: GraphViewOps<'graph>> BaseNodeViewOps<'graph> for NodeView<'grap
 }
 
 impl<G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps> NodeView<'static, G> {
-    pub fn add_metadata<C: CollectProperties>(&self, properties: C) -> Result<(), GraphError> {
-        let properties: Vec<(usize, Prop)> = properties.collect_properties(|name, dtype| {
-            Ok(self
-                .graph
-                .resolve_node_property(name, dtype, true)
+    pub fn add_metadata<PN: AsRef<str>, P: Into<Prop>>(
+        &self,
+        props: impl IntoIterator<Item = (PN, P)>,
+    ) -> Result<(), GraphError> {
+        let is_update = false;
+        self.add_metadata_impl(props, is_update)
+    }
+
+    pub fn update_metadata<PN: AsRef<str>, P: Into<Prop>>(
+        &self,
+        props: impl IntoIterator<Item = (PN, P)>,
+    ) -> Result<(), GraphError> {
+        let is_update = true;
+        self.add_metadata_impl(props, is_update)
+    }
+
+    /// Adds metadata properties to the node.
+    ///
+    /// When `is_update` is true, existing properties are updated, otherwise
+    /// an error is returned if the property already exists.
+    fn add_metadata_impl<PN: AsRef<str>, P: Into<Prop>>(
+        &self,
+        properties: impl IntoIterator<Item = (PN, P)>,
+        is_update: bool,
+    ) -> Result<(), GraphError> {
+        let transaction_manager = self
+            .graph
+            .core_graph()
+            .transaction_manager()
+            .map_err(into_graph_err)?;
+        let wal = self.graph.core_graph().wal().map_err(into_graph_err)?;
+        let transaction_id = transaction_manager.begin_transaction();
+
+        let props_with_status = self.graph.core_graph().validate_props_with_status(
+            true,
+            self.graph.node_meta(),
+            properties.into_iter().map(|(n, p)| (n, p.into())),
+        )?;
+
+        let props = props_with_status
+            .iter()
+            .map(|maybe_new| {
+                let (_, prop_id, prop) = maybe_new.as_ref().inner();
+                (*prop_id, prop.clone())
+            })
+            .collect::<Vec<_>>();
+
+        let vid = self.node;
+
+        let mut writer = if is_update {
+            self.graph
+                .internal_update_node_metadata(vid, props)
                 .map_err(into_graph_err)?
-                .inner())
-        })?;
-        self.graph
-            .internal_add_node_metadata(self.node, &properties)
+        } else {
+            self.graph
+                .internal_add_node_metadata(vid, props)
+                .map_err(into_graph_err)?
+        };
+
+        let props_for_wal = props_with_status
+            .iter()
+            .map(|maybe_new| {
+                let (prop_name, prop_id, prop) = maybe_new.as_ref().inner();
+                (prop_name.as_ref(), *prop_id, prop.clone())
+            })
+            .collect::<Vec<_>>();
+
+        let lsn = wal
+            .log_add_node_metadata(transaction_id, vid, props_for_wal)
             .map_err(into_graph_err)?;
+
+        writer.set_lsn(lsn);
+        transaction_manager.end_transaction(transaction_id);
+        drop(writer);
+
+        if let Err(e) = wal.flush(lsn) {
+            return Err(GraphError::FatalWriteError(e));
+        }
+
         Ok(())
     }
 
     pub fn set_node_type(&self, new_type: &str) -> Result<(), GraphError> {
-        self.graph
-            .resolve_node_and_type(NodeRef::Internal(self.node), new_type)
+        let transaction_manager = self
+            .graph
+            .core_graph()
+            .transaction_manager()
             .map_err(into_graph_err)?;
-        Ok(())
-    }
+        let wal = self.graph.core_graph().wal().map_err(into_graph_err)?;
+        let transaction_id = transaction_manager.begin_transaction();
+        let vid = self.node;
 
-    pub fn update_metadata<C: CollectProperties>(&self, props: C) -> Result<(), GraphError> {
-        let properties: Vec<(usize, Prop)> = props.collect_properties(|name, dtype| {
-            Ok(self
-                .graph
-                .resolve_node_property(name, dtype, true)
-                .map_err(into_graph_err)?
-                .inner())
-        })?;
-        self.graph
-            .internal_update_node_metadata(self.node, &properties)
+        let mut writer = self
+            .graph
+            .atomic_add_node(NodeRef::Internal(vid))
             .map_err(into_graph_err)?;
+
+        if !writer.can_set_type() {
+            // Ignore if the new type is the same as the existing type, else return an error.
+            self.graph
+                .node_meta()
+                .get_node_type_id(new_type)
+                .filter(|&new_type_id| writer.get_type() == new_type_id)
+                .ok_or(MutationError::NodeTypeError)?;
+        }
+
+        let new_type_id = self
+            .graph
+            .node_meta()
+            .get_or_create_node_type_id(new_type)
+            .inner();
+
+        writer.set_type(new_type_id);
+
+        let lsn = wal
+            .log_set_node_type(transaction_id, vid, new_type, new_type_id)
+            .map_err(into_graph_err)?;
+
+        writer.set_lsn(lsn);
+        transaction_manager.end_transaction(transaction_id);
+        drop(writer);
+
+        if let Err(e) = wal.flush(lsn) {
+            return Err(GraphError::FatalWriteError(e));
+        }
+
         Ok(())
     }
 
-    pub fn add_updates<C: CollectProperties, T: TryIntoInputTime>(
+    pub fn add_updates<
+        T: TryIntoInputTime,
+        PN: AsRef<str>,
+        PI: Into<Prop>,
+        PII: IntoIterator<Item = (PN, PI)>,
+    >(
         &self,
         time: T,
-        props: C,
+        props: PII,
+        layer: Option<&str>,
     ) -> Result<(), GraphError> {
-        let t = time_from_input(&self.graph, time)?;
-        let properties: Vec<(usize, Prop)> = props.collect_properties(|name, dtype| {
-            Ok(self
+        let transaction_manager = self
+            .graph
+            .core_graph()
+            .transaction_manager()
+            .map_err(into_graph_err)?;
+        let wal = self.graph.core_graph().wal().map_err(into_graph_err)?;
+        let transaction_id = transaction_manager.begin_transaction();
+        let session = self.graph.write_session().map_err(|err| err.into())?;
+
+        let props_with_status = self
+            .graph
+            .validate_props_with_status(
+                false,
+                self.graph.node_meta(),
+                props.into_iter().map(|(k, v)| (k, v.into())),
+            )
+            .map_err(into_graph_err)?;
+        let layer_id = match layer {
+            None => STATIC_GRAPH_LAYER_ID,
+            Some(_) => self
                 .graph
-                .resolve_node_property(name, dtype, false)
+                .resolve_layer(layer)
                 .map_err(into_graph_err)?
-                .inner())
-        })?;
-        self.graph
-            .internal_add_node(t, self.node, &properties)
-            .map_err(into_graph_err)
+                .inner(),
+        };
+
+        let t = time_from_input_session(&session, time)?;
+        let vid = self.node;
+
+        let mut writer = self
+            .graph
+            .atomic_add_node(NodeRef::Internal(vid))
+            .map_err(into_graph_err)?;
+
+        let props = props_with_status
+            .iter()
+            .map(|maybe_new| {
+                let (_, prop_id, prop) = maybe_new.as_ref().inner();
+                (*prop_id, prop.clone())
+            })
+            .collect::<Vec<_>>();
+
+        writer.internal_add_update(t, layer_id, props);
+
+        let props_for_wal = props_with_status
+            .iter()
+            .map(|maybe_new| {
+                let (prop_name, prop_id, prop) = maybe_new.as_ref().inner();
+                (prop_name.as_ref(), *prop_id, prop.clone())
+            })
+            .collect::<Vec<_>>();
+
+        let lsn = wal
+            .log_add_node(
+                transaction_id,
+                t,
+                None,
+                vid,
+                None,
+                props_for_wal,
+                layer,
+                layer_id,
+            )
+            .map_err(into_graph_err)?;
+
+        writer.set_lsn(lsn);
+        transaction_manager.end_transaction(transaction_id);
+        drop(writer);
+
+        if let Err(e) = wal.flush(lsn) {
+            return Err(GraphError::FatalWriteError(e));
+        }
+
+        Ok(())
     }
 }
diff --git a/raphtory/src/db/graph/nodes.rs b/raphtory/src/db/graph/nodes.rs
index 96ae8431c3..1ea4528636 100644
--- a/raphtory/src/db/graph/nodes.rs
+++ b/raphtory/src/db/graph/nodes.rs
@@ -33,7 +33,7 @@ pub struct Nodes<'graph, G, GH = G, F = Const<bool>> {
     pub(crate) base_graph: G,
     pub(crate) graph: GH,
     pub(crate) predicate: F,
-    pub(crate) nodes: Option<Index<VID>>,
+    pub(crate) nodes: Index<VID>,
     _marker: PhantomData<&'graph ()>,
 }
 
@@ -118,11 +118,13 @@ where
     G: GraphViewOps<'graph> + Clone,
 {
     pub fn new(graph: G) -> Self {
+        let base_graph = graph.clone();
+        let node_index = base_graph.core_graph().node_state_index();
         Self {
-            base_graph: graph.clone(),
-            graph: graph.clone(),
+            base_graph,
+            graph,
+            nodes: node_index.into(),
             predicate: NO_FILTER,
-            nodes: None,
             _marker: PhantomData,
         }
     }
@@ -134,7 +136,7 @@ where
     GH: GraphViewOps<'graph> + 'graph,
     F: NodeFilterOp + Clone + 'graph,
 {
-    pub fn new_filtered(base_graph: G, graph: GH, predicate: F, nodes: Option<Index<VID>>) -> Self {
+    pub fn new_filtered(base_graph: G, graph: GH, predicate: F, nodes: Index<VID>) -> Self {
         Self {
             base_graph,
             graph,
@@ -146,28 +148,34 @@ where
 
     pub fn node_list(&self) -> NodeList {
         match self.nodes.clone() {
-            None => self.graph.node_list(),
-            Some(elems) => NodeList::List { elems },
+            elems @ Index::Partial(_) => NodeList::List { elems },
+            _ => self.graph.node_list(),
         }
     }
 
+    pub(crate) fn par_iter_refs(
+        &self,
+        g: GraphStorage,
+    ) -> impl ParallelIterator<Item = VID> + 'graph {
+        let view = self.base_graph.clone();
+        let node_select = self.predicate.clone();
+        self.node_list().nodes_par_iter(&g).filter(move |&vid| {
+            g.try_core_node(vid)
+                .is_some_and(|node| view.filter_node(node.as_ref()) && node_select.apply(&g, vid))
+        })
+    }
+
     pub fn indexed(&self, index: Index<VID>) -> Nodes<'graph, G, GH, F> {
         Nodes::new_filtered(
             self.base_graph.clone(),
             self.graph.clone(),
             self.predicate.clone(),
-            Some(index),
+            index,
         )
     }
 
-    pub(crate) fn par_iter_refs(&self) -> impl ParallelIterator<Item = VID> + 'graph {
-        let g = self.base_graph.core_graph().lock();
-        let view = self.base_graph.clone();
-        let node_select = self.predicate.clone();
-        self.node_list().into_par_iter().filter(move |&vid| {
-            g.try_core_node(vid)
-                .is_some_and(|node| view.filter_node(node.as_ref()) && node_select.apply(&g, vid))
-        })
+    fn locked_storage(&self) -> GraphStorage {
+        self.base_graph.core_graph().lock()
     }
 
     #[inline]
@@ -176,10 +184,14 @@ where
         self.iter_vids(g)
     }
 
-    fn iter_vids(&self, g: GraphStorage) -> impl Iterator<Item = VID> + Send + Sync + 'graph {
+    pub(crate) fn iter_vids(
+        &self,
+        g: GraphStorage,
+    ) -> impl Iterator<Item = VID> + Send + Sync + 'graph {
         let view = self.base_graph.clone();
         let selector = self.predicate.clone();
-        self.node_list().into_iter().filter(move |&vid| {
+
+        self.node_list().nodes_iter(&g).filter(move |&vid| {
             g.try_core_node(vid)
                 .is_some_and(|node| view.filter_node(node.as_ref()) && selector.apply(&g, vid))
         })
@@ -220,29 +232,36 @@ where
     pub fn par_iter(
         &self,
     ) -> impl ParallelIterator<Item = NodeView<'_, &GH>> + use<'_, 'graph, G, GH, F> {
-        self.par_iter_refs()
+        let g = self.base_graph.core_graph().lock();
+        self.par_iter_refs(g)
             .map(|v| NodeView::new_internal(&self.graph, v))
     }
 
     pub fn into_par_iter(self) -> impl ParallelIterator<Item = NodeView<'graph, GH>> + 'graph {
-        self.par_iter_refs()
+        let g = self.locked_storage();
+        self.par_iter_refs(g)
             .map(move |n| NodeView::new_internal(self.graph.clone(), n))
     }
 
     /// Returns the number of nodes in the graph.
     #[inline]
     pub fn len(&self) -> usize {
-        match self.nodes.as_ref() {
-            None => {
+        match &self.nodes {
+            Index::Full(_) => {
                 if self.is_list_filtered() {
-                    self.par_iter_refs().count()
+                    let g = self.locked_storage();
+                    self.par_iter_refs(g).count()
                 } else {
-                    self.graph.node_list().len()
+                    match self.graph.node_list() {
+                        NodeList::All => self.graph.unfiltered_num_nodes(self.graph.layer_ids()),
+                        NodeList::List { elems } => elems.len(),
+                    }
                 }
             }
-            Some(nodes) => {
-                if self.is_filtered() {
-                    self.par_iter_refs().count()
+            Index::Partial(nodes) => {
+                if self.is_list_filtered() {
+                    let g = self.locked_storage();
+                    self.par_iter_refs(g).count()
                 } else {
                     nodes.len()
                 }
@@ -301,7 +320,7 @@ where
     }
 
     pub fn is_list_filtered(&self) -> bool {
-        !self.graph.node_list_trusted() || self.predicate.is_filtered()
+        !self.graph.node_list_trusted() || self.predicate.is_domain_filtered()
     }
 
     pub fn is_filtered(&self) -> bool {
@@ -309,13 +328,10 @@ where
     }
 
     pub fn contains<V: AsNodeRef>(&self, node: V) -> bool {
-        (&self.base_graph)
+        (&&self.base_graph)
             .node(node)
             .filter(|node| {
-                self.nodes
-                    .as_ref()
-                    .map(|nodes| nodes.contains(&node.node))
-                    .unwrap_or(true)
+                self.nodes.contains(&node.node)
                     && self
                         .predicate
                         .apply(self.base_graph.core_graph(), node.node)
@@ -341,12 +357,17 @@ where
         &self,
         filter: Filter,
     ) -> Self::IterFiltered<Filter> {
+        let domain = filter.domain(self.graph.core_graph());
+        let nodes = match domain {
+            NodeList::All => self.nodes.clone(),
+            NodeList::List { elems } => self.nodes.intersection(&elems),
+        };
         let predicate = self.predicate.clone().and(filter);
         Nodes {
             base_graph: self.base_graph.clone(),
             graph: self.graph.clone(),
             predicate,
-            nodes: self.nodes.clone(),
+            nodes,
             _marker: Default::default(),
         }
     }
diff --git a/raphtory/src/db/graph/path.rs b/raphtory/src/db/graph/path.rs
index a66f8dba20..57c6924cc3 100644
--- a/raphtory/src/db/graph/path.rs
+++ b/raphtory/src/db/graph/path.rs
@@ -62,7 +62,22 @@ impl<'graph, G: GraphViewOps<'graph>> PathFromGraph<'graph, G> {
         (self.nodes)()
     }
 
-    pub fn iter(&self) -> impl Iterator<Item = PathFromNode<'graph, G>> + Send + 'graph {
+    pub fn iter(
+        &self,
+    ) -> impl Iterator<Item = (NodeView<'graph, G>, PathFromNode<'graph, G>)> + Send + 'graph {
+        let base_graph = self.base_graph.clone();
+        let op = self.op.clone();
+        self.base_iter().map(move |v| {
+            let op = op.clone();
+            let node_op = Arc::new(move || op(v));
+            (
+                NodeView::new_internal(base_graph.clone(), v),
+                PathFromNode::new_one_hop_filtered(base_graph.clone(), node_op),
+            )
+        })
+    }
+
+    pub fn iter_values(&self) -> impl Iterator<Item = PathFromNode<'graph, G>> + Send + 'graph {
         let base_graph = self.base_graph.clone();
         let op = self.op.clone();
         self.base_iter().map(move |v| {
@@ -116,7 +131,7 @@ impl<'graph, G: GraphViewOps<'graph>> PathFromGraph<'graph, G> {
     }
 
     pub fn collect(&self) -> Vec<Vec<NodeView<'graph, G>>> {
-        self.iter().map(|path| path.collect()).collect()
+        self.iter_values().map(|path| path.collect()).collect()
     }
 
     pub fn combined_history(&self) -> History<'graph, Self> {
@@ -126,7 +141,8 @@ impl<'graph, G: GraphViewOps<'graph>> PathFromGraph<'graph, G> {
 
 impl<'graph, G: GraphViewOps<'graph>> BaseNodeViewOps<'graph> for PathFromGraph<'graph, G> {
     type Graph = G;
-    type ValueType<T: ArrowNodeOp + 'graph> = BoxedLIter<'graph, BoxedLIter<'graph, T::Output>>;
+    type ValueType<T: ArrowNodeOp + 'graph> =
+        BoxedLIter<'graph, (NodeView<'graph, G>, BoxedLIter<'graph, T::Output>)>;
     type PropType = NodeView<'graph, G>;
     type PathType = PathFromGraph<'graph, G>;
     type Edges = NestedEdges<'graph, G>;
@@ -139,14 +155,8 @@ impl<'graph, G: GraphViewOps<'graph>> BaseNodeViewOps<'graph> for PathFromGraph<
     where
         <F as NodeOp>::Output: 'graph,
     {
-        let storage = self.base_graph.core_graph().lock();
-        self.iter_refs()
-            .map(move |it| {
-                let op = op.clone();
-                let storage = storage.clone();
-                it.map(move |node| op.apply(&storage, node))
-                    .into_dyn_boxed()
-            })
+        self.iter()
+            .map(move |(node, path)| (node, path.map(op.clone())))
             .into_dyn_boxed()
     }
 
@@ -192,7 +202,7 @@ impl<'graph, G: GraphViewOps<'graph>> BaseNodeViewOps<'graph> for PathFromGraph<
 }
 
 impl<'graph, G: GraphViewOps<'graph>> IntoIterator for PathFromGraph<'graph, G> {
-    type Item = PathFromNode<'graph, G>;
+    type Item = (NodeView<'graph, G>, PathFromNode<'graph, G>);
     type IntoIter = BoxedLIter<'graph, Self::Item>;
 
     fn into_iter(self) -> Self::IntoIter {
@@ -202,7 +212,10 @@ impl<'graph, G: GraphViewOps<'graph>> IntoIterator for PathFromGraph<'graph, G>
             .map(move |node| {
                 let op = op.clone();
                 let node_op = Arc::new(move || op(node));
-                PathFromNode::new_one_hop_filtered(base_graph.clone(), node_op)
+                (
+                    NodeView::new_internal(base_graph.clone(), node),
+                    PathFromNode::new_one_hop_filtered(base_graph.clone(), node_op),
+                )
             })
             .into_dyn_boxed()
     }
diff --git a/raphtory/src/db/graph/views/cached_view.rs b/raphtory/src/db/graph/views/cached_view.rs
index 7688f7f08a..534a556843 100644
--- a/raphtory/src/db/graph/views/cached_view.rs
+++ b/raphtory/src/db/graph/views/cached_view.rs
@@ -14,7 +14,7 @@ use crate::{
 };
 use raphtory_api::{
     core::{
-        entities::ELID,
+        entities::{LayerId, ELID},
         storage::timeindex::{AsTime, EventTime},
     },
     inherit::Base,
@@ -22,7 +22,7 @@ use raphtory_api::{
 use raphtory_storage::{
     core_ops::CoreGraphOps,
     graph::{
-        edges::{edge_ref::EdgeStorageRef, edge_storage_ops::EdgeStorageOps},
+        edges::edge_storage_ops::EdgeStorageOps,
         nodes::{node_ref::NodeStorageRef, node_storage_ops::NodeStorageOps},
     },
 };
@@ -32,6 +32,7 @@ use std::{
     fmt::{Debug, Formatter},
     sync::Arc,
 };
+use storage::EdgeEntryRef;
 
 #[derive(Clone)]
 pub struct CachedView<G> {
@@ -81,7 +82,7 @@ impl<'graph, G: GraphViewOps<'graph>> CachedView<G> {
                 .collect(),
         );
         for l_name in graph.unique_layers() {
-            let l_id = graph.get_layer_id(&l_name).unwrap();
+            let l_id = graph.get_layer_id(&l_name).unwrap().0;
             let layer_g = graph.layers(l_name).unwrap();
 
             let nodes = layer_g
@@ -172,7 +173,7 @@ impl<'graph, G: GraphViewOps<'graph>> InternalExplodedEdgeFilterOps for CachedVi
         _layer_ids: &LayerIds,
     ) -> bool {
         self.layered_mask
-            .get(eid.layer())
+            .get(eid.layer().0)
             .is_some_and(|(_, _, exploded_filter)| {
                 exploded_filter
                     .as_ref()
@@ -194,9 +195,9 @@ impl<'graph, G: GraphViewOps<'graph>> InternalEdgeLayerFilterOps for CachedView<
         self.graph.internal_layer_filter_edge_list_trusted()
     }
 
-    fn internal_filter_edge_layer(&self, edge: EdgeStorageRef, layer: usize) -> bool {
+    fn internal_filter_edge_layer(&self, edge: EdgeEntryRef, layer: LayerId) -> bool {
         self.layered_mask
-            .get(layer)
+            .get(layer.0)
             .is_some_and(|(_, edge_filter, _)| edge_filter.contains(edge.eid().as_u64()))
     }
 
@@ -216,7 +217,7 @@ impl<'graph, G: GraphViewOps<'graph>> InternalEdgeFilterOps for CachedView<G> {
     }
 
     #[inline]
-    fn internal_filter_edge(&self, edge: EdgeStorageRef, layer_ids: &LayerIds) -> bool {
+    fn internal_filter_edge(&self, edge: EdgeEntryRef, layer_ids: &LayerIds) -> bool {
         let filter_fn =
             |(_, edges, _): &(RoaringTreemap, RoaringTreemap, Option<RoaringTreemap>)| {
                 edges.contains(edge.eid().as_u64())
@@ -224,10 +225,10 @@ impl<'graph, G: GraphViewOps<'graph>> InternalEdgeFilterOps for CachedView<G> {
         match layer_ids {
             LayerIds::None => false,
             LayerIds::All => self.layered_mask.iter().any(filter_fn),
-            LayerIds::One(id) => self.layered_mask.get(*id).is_some_and(filter_fn),
+            LayerIds::One(id) => self.layered_mask.get(id.0).is_some_and(filter_fn),
             LayerIds::Multiple(multiple) => multiple
                 .iter()
-                .any(|id| self.layered_mask.get(id).is_some_and(filter_fn)),
+                .any(|id| self.layered_mask.get(id.0).is_some_and(filter_fn)),
         }
     }
 
@@ -263,12 +264,12 @@ impl<'graph, G: GraphViewOps<'graph>> InternalNodeFilterOps for CachedView<G> {
             LayerIds::All => self.global_nodes_mask.contains(node.vid().as_u64()),
             LayerIds::One(id) => self
                 .layered_mask
-                .get(*id)
+                .get(id.0)
                 .map(|(nodes, _, _)| nodes.contains(node.vid().as_u64()))
                 .unwrap_or(false),
             LayerIds::Multiple(multiple) => multiple.iter().any(|id| {
                 self.layered_mask
-                    .get(id)
+                    .get(id.0)
                     .map(|(nodes, _, _)| nodes.contains(node.vid().as_u64()))
                     .unwrap_or(false)
             }),
diff --git a/raphtory/src/db/graph/views/deletion_graph.rs b/raphtory/src/db/graph/views/deletion_graph.rs
index b1e12c647f..1ada0ddb1e 100644
--- a/raphtory/src/db/graph/views/deletion_graph.rs
+++ b/raphtory/src/db/graph/views/deletion_graph.rs
@@ -1,31 +1,35 @@
+#[cfg(feature = "io")]
+use crate::serialise::GraphPaths;
 use crate::{
-    core::{
-        storage::timeindex::{AsTime, EventTime, TimeIndex, TimeIndexOps},
-        utils::iter::GenLockedDIter,
-    },
+    core::storage::timeindex::{AsTime, EventTime, TimeIndex, TimeIndexOps},
     db::{
         api::{
-            properties::internal::InheritPropertiesOps, storage::storage::Storage,
+            properties::internal::InheritPropertiesOps,
+            storage::storage::{PersistenceStrategy, Storage},
             view::internal::*,
         },
         graph::graph::graph_equal,
     },
+    errors::GraphError,
     prelude::*,
 };
 use raphtory_api::{
     core::entities::properties::tprop::TPropOps,
     inherit::Base,
-    iter::{BoxedLDIter, IntoDynDBoxed},
+    iter::{BoxedLIter, IntoDynBoxed},
     GraphType,
 };
+use raphtory_core::utils::iter::GenLockedIter;
 use raphtory_storage::{graph::graph::GraphStorage, mutation::InheritMutationOps};
-use serde::{Deserialize, Serialize};
 use std::{
     fmt::{Display, Formatter},
-    iter,
-    ops::{Deref, Range},
+    ops::Range,
     sync::Arc,
 };
+use storage::{
+    api::graph_props::{GraphPropEntryOps, GraphPropRefOps},
+    Config, Extension,
+};
 
 /// A graph view where an edge remains active from the time it is added until it is explicitly marked as deleted.
 ///
@@ -35,7 +39,7 @@ use std::{
 /// the edge is not considered active at the start of the window, even if there are simultaneous addition events.
 ///
 ///
-#[derive(Clone, Debug, Serialize, Deserialize, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct PersistentGraph(pub(crate) Arc<Storage>);
 
 impl Static for PersistentGraph {}
@@ -91,6 +95,108 @@ impl PersistentGraph {
         Self::default()
     }
 
+    /// Create a new graph with config
+    ///
+    /// Returns:
+    ///
+    /// A raphtory graph
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use raphtory::prelude::*;
+    ///
+    /// let g = PersistentGraph::new_with_config(Config::default().with_max_node_page_len(262144)).unwrap();
+    /// ```
+    pub fn new_with_config(config: Config) -> Result<Self, GraphError> {
+        Ok(Self(Arc::new(Storage::new_with_config(config)?)))
+    }
+
+    /// Create a new persistent graph at a specific path
+    ///
+    /// # Arguments
+    /// * `path` - The path to the storage location
+    /// # Returns
+    /// A raphtory graph with storage at the specified path
+    /// # Example
+    /// ```no_run
+    /// use raphtory::prelude::PersistentGraph;
+    /// let g = PersistentGraph::new_at_path("/path/to/storage");
+    /// ```
+    #[cfg(feature = "io")]
+    pub fn new_at_path_with_config(
+        path: &(impl GraphPaths + ?Sized),
+        config: Config,
+    ) -> Result<Self, GraphError> {
+        if !Extension::disk_storage_enabled() {
+            return Err(GraphError::DiskGraphNotEnabled);
+        }
+        path.init()?;
+        let graph = Self(Arc::new(Storage::new_at_path_with_config(
+            path.graph_path()?,
+            config,
+        )?));
+        path.write_metadata(&graph)?;
+        Ok(graph)
+    }
+
+    /// Create a new persistent graph at a specific path
+    ///
+    /// # Arguments
+    /// * `path` - The path to the storage location
+    /// # Returns
+    /// A raphtory graph with storage at the specified path
+    /// # Example
+    /// ```no_run
+    /// use raphtory::prelude::PersistentGraph;
+    /// let g = PersistentGraph::new_at_path("/path/to/storage");
+    /// ```
+    #[cfg(feature = "io")]
+    pub fn new_at_path(path: &(impl GraphPaths + ?Sized)) -> Result<Self, GraphError> {
+        if !Extension::disk_storage_enabled() {
+            return Err(GraphError::DiskGraphNotEnabled);
+        }
+        path.init()?;
+        let graph = Self(Arc::new(Storage::new_at_path(path.graph_path()?)?));
+        path.write_metadata(&graph)?;
+        Ok(graph)
+    }
+
+    /// Load a graph from a specific path
+    /// # Arguments
+    /// * `path` - The path to the storage location
+    /// # Returns
+    /// A raphtory graph loaded from the specified path
+    /// # Example
+    /// ```no_run
+    /// use raphtory::prelude::Graph;
+    /// let g = Graph::load("/path/to/storage");    ///
+    #[cfg(feature = "io")]
+    pub fn load(path: &(impl GraphPaths + ?Sized)) -> Result<Self, GraphError> {
+        Ok(Self(Arc::new(Storage::load(path.graph_path()?)?)))
+    }
+
+    /// Load a graph from a specific path overriding config
+    /// # Arguments
+    /// * `path` - The path to the storage location
+    /// * `config` - The new config (note that it is not possible to change page sizes)
+    /// # Returns
+    /// A raphtory graph loaded from the specified path
+    /// # Example
+    /// ```no_run
+    /// use raphtory::prelude::Graph;
+    /// let g = Graph::load("/path/to/storage");    ///
+    #[cfg(feature = "io")]
+    pub fn load_with_config(
+        path: &(impl GraphPaths + ?Sized),
+        config: Config,
+    ) -> Result<Self, GraphError> {
+        Ok(Self(Arc::new(Storage::load_with_config(
+            path.graph_path()?,
+            config,
+        )?)))
+    }
+
     pub fn from_storage(storage: Arc<Storage>) -> Self {
         Self(storage)
     }
@@ -116,6 +222,7 @@ impl<'graph, G: GraphViewOps<'graph>> PartialEq<G> for PersistentGraph {
 
 impl Base for PersistentGraph {
     type Base = Storage;
+
     #[inline(always)]
     fn base(&self) -> &Self::Base {
         &self.0
@@ -188,7 +295,7 @@ impl GraphTimeSemanticsOps for PersistentGraph {
         self.0.has_temporal_prop(prop_id)
     }
 
-    fn temporal_prop_iter(&self, prop_id: usize) -> BoxedLDIter<'_, (EventTime, Prop)> {
+    fn temporal_prop_iter(&self, prop_id: usize) -> BoxedLIter<'_, (EventTime, Prop)> {
         self.0.temporal_prop_iter(prop_id)
     }
 
@@ -199,24 +306,58 @@ impl GraphTimeSemanticsOps for PersistentGraph {
             .is_some()
     }
 
+    /// Iterates over temporal property values within a time window `[start, end)`.
+    ///
+    /// # Returns
+    /// A boxed iterator yielding `(TimeIndexEntry, Prop)` tuples.
     fn temporal_prop_iter_window(
         &self,
         prop_id: usize,
         start: EventTime,
         end: EventTime,
-    ) -> BoxedLDIter<'_, (EventTime, Prop)> {
-        if let Some(prop) = self.graph_meta().get_temporal_prop(prop_id) {
-            let first =
-                persisted_prop_value_at(start.t(), &*prop, &TimeIndex::Empty).map(|v| (start, v));
+    ) -> BoxedLIter<'_, (EventTime, Prop)> {
+        let graph_entry = self.core_graph().graph_entry();
+
+        GenLockedIter::from(graph_entry, move |entry| {
+            let tprop = entry.as_ref().get_temporal_prop(prop_id);
+
+            // Get the property value that was active at the start of the window.
+            let first = persisted_prop_value_at(start.t(), tprop, &TimeIndex::Empty)
+                .map(|prop_value| (start, prop_value));
+
+            // Chain the initial prop with the rest of the props that occur
+            // within the window.
             first
                 .into_iter()
-                .chain(GenLockedDIter::from(prop, |prop| {
-                    prop.deref().iter_window(start..end).into_dyn_dboxed()
-                }))
-                .into_dyn_dboxed()
-        } else {
-            iter::empty().into_dyn_dboxed()
-        }
+                .chain(tprop.iter_window(start..end))
+                .into_dyn_boxed()
+        })
+        .into_dyn_boxed()
+    }
+
+    fn temporal_prop_iter_window_rev(
+        &self,
+        prop_id: usize,
+        start: EventTime,
+        end: EventTime,
+    ) -> BoxedLIter<'_, (EventTime, Prop)> {
+        let graph_entry = self.core_graph().graph_entry();
+
+        GenLockedIter::from(graph_entry, move |entry| {
+            let tprop = entry.as_ref().get_temporal_prop(prop_id);
+
+            // Get the property value that was active at the start of the window.
+            let first = persisted_prop_value_at(start.t(), tprop, &TimeIndex::Empty)
+                .map(|prop_value| (start, prop_value));
+
+            // Chain the initial prop with the rest of the props that occur
+            // within the window, in reverse order.
+            tprop
+                .iter_window_rev(start..end)
+                .chain(first)
+                .into_dyn_boxed()
+        })
+        .into_dyn_boxed()
     }
 
     fn temporal_prop_last_at(&self, prop_id: usize, t: EventTime) -> Option<(EventTime, Prop)> {
diff --git a/raphtory/src/db/graph/views/filter/and_filtered_graph.rs b/raphtory/src/db/graph/views/filter/and_filtered_graph.rs
index f24e59f6c0..f34da45acd 100644
--- a/raphtory/src/db/graph/views/filter/and_filtered_graph.rs
+++ b/raphtory/src/db/graph/views/filter/and_filtered_graph.rs
@@ -11,14 +11,14 @@ use crate::{
 };
 use raphtory_api::{
     core::{
-        entities::{LayerIds, ELID},
+        entities::{LayerId, LayerIds, ELID},
         storage::timeindex::EventTime,
     },
     inherit::Base,
 };
 use raphtory_storage::{
     core_ops::InheritCoreGraphOps,
-    graph::{edges::edge_ref::EdgeStorageRef, nodes::node_ref::NodeStorageRef},
+    graph::{edges::edge_ref::EdgeEntryRef, nodes::node_ref::NodeStorageRef},
 };
 
 #[derive(Debug, Clone)]
@@ -105,7 +105,7 @@ impl<G, L: InternalEdgeLayerFilterOps, R: InternalEdgeLayerFilterOps> InternalEd
             && self.right.internal_layer_filter_edge_list_trusted()
     }
 
-    fn internal_filter_edge_layer(&self, edge: EdgeStorageRef, layer: usize) -> bool {
+    fn internal_filter_edge_layer(&self, edge: EdgeEntryRef, layer: LayerId) -> bool {
         self.left.internal_filter_edge_layer(edge, layer)
             && self.right.internal_filter_edge_layer(edge, layer)
     }
@@ -143,7 +143,7 @@ impl<G, L: InternalEdgeFilterOps, R: InternalEdgeFilterOps> InternalEdgeFilterOp
     }
 
     #[inline]
-    fn internal_filter_edge(&self, edge: EdgeStorageRef, layer_ids: &LayerIds) -> bool {
+    fn internal_filter_edge(&self, edge: EdgeEntryRef, layer_ids: &LayerIds) -> bool {
         self.left.internal_filter_edge(edge, layer_ids)
             && self.right.internal_filter_edge(edge, layer_ids)
     }
diff --git a/raphtory/src/db/graph/views/filter/edge_node_filtered_graph.rs b/raphtory/src/db/graph/views/filter/edge_node_filtered_graph.rs
index d635d87de0..a43e5b904b 100644
--- a/raphtory/src/db/graph/views/filter/edge_node_filtered_graph.rs
+++ b/raphtory/src/db/graph/views/filter/edge_node_filtered_graph.rs
@@ -14,7 +14,7 @@ use crate::db::{
 use raphtory_api::{core::entities::LayerIds, inherit::Base};
 use raphtory_storage::{
     core_ops::InheritCoreGraphOps,
-    graph::edges::{edge_ref::EdgeStorageRef, edge_storage_ops::EdgeStorageOps},
+    graph::edges::{edge_ref::EdgeEntryRef, edge_storage_ops::EdgeStorageOps},
 };
 
 #[derive(Debug, Clone)]
@@ -71,7 +71,7 @@ impl<G: GraphView, F: NodeFilterOp> InternalEdgeFilterOps for EdgeNodeFilteredGr
     }
 
     #[inline]
-    fn internal_filter_edge(&self, edge: EdgeStorageRef, layer_ids: &LayerIds) -> bool {
+    fn internal_filter_edge(&self, edge: EdgeEntryRef, layer_ids: &LayerIds) -> bool {
         if !self.graph.internal_filter_edge(edge, layer_ids) {
             return false;
         }
diff --git a/raphtory/src/db/graph/views/filter/edge_property_filtered_graph.rs b/raphtory/src/db/graph/views/filter/edge_property_filtered_graph.rs
index 5e8145fea6..cb15addec0 100644
--- a/raphtory/src/db/graph/views/filter/edge_property_filtered_graph.rs
+++ b/raphtory/src/db/graph/views/filter/edge_property_filtered_graph.rs
@@ -15,7 +15,8 @@ use crate::{
     prelude::GraphViewOps,
 };
 use raphtory_api::inherit::Base;
-use raphtory_storage::{core_ops::InheritCoreGraphOps, graph::edges::edge_ref::EdgeStorageRef};
+use raphtory_storage::core_ops::InheritCoreGraphOps;
+use storage::EdgeEntryRef;
 
 #[derive(Debug, Clone)]
 pub struct EdgePropertyFilteredGraph<G> {
@@ -75,7 +76,7 @@ impl<'graph, G: GraphViewOps<'graph>> InternalEdgeFilterOps for EdgePropertyFilt
     }
 
     #[inline]
-    fn internal_filter_edge(&self, edge: EdgeStorageRef, layer_ids: &LayerIds) -> bool {
+    fn internal_filter_edge(&self, edge: EdgeEntryRef, layer_ids: &LayerIds) -> bool {
         self.graph.internal_filter_edge(edge, layer_ids)
             && self.filter.matches_edge(&self.graph, self.prop_id, edge)
     }
diff --git a/raphtory/src/db/graph/views/filter/model/filter.rs b/raphtory/src/db/graph/views/filter/model/filter.rs
index cde2266bb4..0b9fdebbe1 100644
--- a/raphtory/src/db/graph/views/filter/model/filter.rs
+++ b/raphtory/src/db/graph/views/filter/model/filter.rs
@@ -69,11 +69,13 @@ impl Filter {
 
     pub fn is_in(
         field_name: impl Into<String>,
-        field_values: impl IntoIterator<Item = String>,
+        field_values: impl IntoIterator<Item = impl Into<String>>,
     ) -> Self {
         Self {
             field_name: field_name.into(),
-            field_value: FilterValue::Set(Arc::new(field_values.into_iter().collect())),
+            field_value: FilterValue::Set(Arc::new(
+                field_values.into_iter().map(|s| s.into()).collect(),
+            )),
             operator: FilterOperator::IsIn,
         }
     }
@@ -85,11 +87,13 @@ impl Filter {
     ///     field_values (list[str]):
     pub fn is_not_in(
         field_name: impl Into<String>,
-        field_values: impl IntoIterator<Item = String>,
+        field_values: impl IntoIterator<Item = impl Into<String>>,
     ) -> Self {
         Self {
             field_name: field_name.into(),
-            field_value: FilterValue::Set(Arc::new(field_values.into_iter().collect())),
+            field_value: FilterValue::Set(Arc::new(
+                field_values.into_iter().map(|s| s.into()).collect(),
+            )),
             operator: FilterOperator::IsNotIn,
         }
     }
diff --git a/raphtory/src/db/graph/views/filter/model/node_filter/mod.rs b/raphtory/src/db/graph/views/filter/model/node_filter/mod.rs
index 7052b4f6c9..9ccfa9a0e3 100644
--- a/raphtory/src/db/graph/views/filter/model/node_filter/mod.rs
+++ b/raphtory/src/db/graph/views/filter/model/node_filter/mod.rs
@@ -295,7 +295,7 @@ impl CreateFilter for NodeTypeFilter {
         let node_types_filter = graph
             .node_meta()
             .node_type_meta()
-            .get_keys()
+            .keys()
             .iter()
             .map(|k| self.0.matches(Some(k))) // TODO: _default check
             .collect::<Vec<_>>();
@@ -312,7 +312,7 @@ impl CreateFilter for NodeTypeFilter {
         let node_types_filter = graph
             .node_meta()
             .node_type_meta()
-            .get_keys()
+            .keys()
             .iter()
             .map(|k| self.0.matches(Some(k))) // TODO: _default check
             .collect::<Vec<_>>();
diff --git a/raphtory/src/db/graph/views/filter/model/node_filter/ops.rs b/raphtory/src/db/graph/views/filter/model/node_filter/ops.rs
index 192f374535..41a1b819f6 100644
--- a/raphtory/src/db/graph/views/filter/model/node_filter/ops.rs
+++ b/raphtory/src/db/graph/views/filter/model/node_filter/ops.rs
@@ -101,14 +101,17 @@ pub trait NodeFilterOps: InternalNodeFilterBuilder {
         self.wrap(filter.into())
     }
 
-    fn is_in(&self, values: impl IntoIterator<Item = String>) -> Self::Wrapped<Self::FilterType> {
+    fn is_in(
+        &self,
+        values: impl IntoIterator<Item = impl Into<String>>,
+    ) -> Self::Wrapped<Self::FilterType> {
         let filter = Filter::is_in(self.field_name(), values);
         self.wrap(filter.into())
     }
 
     fn is_not_in(
         &self,
-        values: impl IntoIterator<Item = String>,
+        values: impl IntoIterator<Item = impl Into<String>>,
     ) -> Self::Wrapped<Self::FilterType> {
         let filter = Filter::is_not_in(self.field_name(), values);
         self.wrap(filter.into())
diff --git a/raphtory/src/db/graph/views/filter/model/node_state_filter.rs b/raphtory/src/db/graph/views/filter/model/node_state_filter.rs
index ddbb085cc3..f796de3d9f 100644
--- a/raphtory/src/db/graph/views/filter/model/node_state_filter.rs
+++ b/raphtory/src/db/graph/views/filter/model/node_state_filter.rs
@@ -17,7 +17,7 @@ use raphtory_storage::graph::graph::GraphStorage;
 /// Does NOT depend on the graph type `G` at runtime; it only needs the column + optional keys.
 #[derive(Clone)]
 pub struct NodeStateBoolColOp {
-    keys: Option<Index<VID>>,
+    keys: Index<VID>,
     col: BooleanArray,
 }
 
@@ -52,10 +52,7 @@ impl NodeStateBoolColOp {
 
     #[inline]
     fn row_index(&self, node: VID) -> Option<usize> {
-        match &self.keys {
-            Some(index) => index.index(&node),
-            None => Some(node.0),
-        }
+        self.keys.index(&node)
     }
 
     #[inline]
diff --git a/raphtory/src/db/graph/views/filter/model/property_filter/evaluate.rs b/raphtory/src/db/graph/views/filter/model/property_filter/evaluate.rs
index 814270624f..d9e1712507 100644
--- a/raphtory/src/db/graph/views/filter/model/property_filter/evaluate.rs
+++ b/raphtory/src/db/graph/views/filter/model/property_filter/evaluate.rs
@@ -1,19 +1,27 @@
 use crate::{db::graph::views::filter::model::Op, prelude::PropertyFilter};
 use raphtory_api::core::entities::properties::prop::{Prop, PropType};
-use std::sync::Arc;
+use std::borrow::Borrow;
 
 enum ValueType {
     Seq(Vec<Prop>),
     Scalar(Option<Prop>),
 }
 
-pub fn aggregate_values(vals: &[Prop], op: Op) -> Option<Prop> {
-    fn scan_u64_sum(vals: &[Prop]) -> Option<(bool, u64, u128)> {
+pub fn aggregate_values<P: Borrow<Prop>, I: IntoIterator<Item = P>>(
+    vals: I,
+    op: Op,
+) -> Option<Prop> {
+    let mut vals = vals.into_iter().peekable();
+    fn scan_u64_sum<P: Borrow<Prop>>(
+        vals: impl IntoIterator<Item = P>,
+    ) -> Option<(bool, u64, u128, usize)> {
         let mut sum64: u64 = 0;
         let mut sum128: u128 = 0;
         let mut promoted = false;
+        let mut count = 0usize;
 
         for p in vals {
+            let p = p.borrow();
             let x = p.as_u64_lossless()?;
             if !promoted {
                 if let Some(s) = sum64.checked_add(x) {
@@ -25,16 +33,21 @@ pub fn aggregate_values(vals: &[Prop], op: Op) -> Option<Prop> {
             } else {
                 sum128 += x as u128;
             }
+            count += 1;
         }
-        Some((promoted, sum64, sum128))
+        Some((promoted, sum64, sum128, count))
     }
 
-    fn scan_i64_sum(vals: &[Prop]) -> Option<(bool, i64, i128)> {
+    fn scan_i64_sum<P: Borrow<Prop>>(
+        vals: impl IntoIterator<Item = P>,
+    ) -> Option<(bool, i64, i128, usize)> {
         let mut sum64: i64 = 0;
         let mut sum128: i128 = 0;
         let mut promoted = false;
+        let mut count = 0;
 
         for p in vals {
+            let p = p.borrow();
             let x = p.as_i64_lossless()?;
             if !promoted {
                 if let Some(s) = sum64.checked_add(x) {
@@ -46,16 +59,18 @@ pub fn aggregate_values(vals: &[Prop], op: Op) -> Option<Prop> {
             } else {
                 sum128 += x as i128;
             }
+            count += 1;
         }
-        Some((promoted, sum64, sum128))
+        Some((promoted, sum64, sum128, count))
     }
 
-    fn scan_u64_min_max(vals: &[Prop]) -> Option<(u64, u64)> {
-        let mut it = vals.iter();
-        let first = it.next()?.as_u64_lossless()?;
+    fn scan_u64_min_max<P: Borrow<Prop>>(vals: impl IntoIterator<Item = P>) -> Option<(u64, u64)> {
+        let mut it = vals.into_iter();
+        let first = it.next()?.borrow().as_u64_lossless()?;
         let mut min_v = first;
         let mut max_v = first;
         for p in it {
+            let p = p.borrow();
             let x = p.as_u64_lossless()?;
             if x < min_v {
                 min_v = x;
@@ -67,12 +82,13 @@ pub fn aggregate_values(vals: &[Prop], op: Op) -> Option<Prop> {
         Some((min_v, max_v))
     }
 
-    fn scan_i64_min_max(vals: &[Prop]) -> Option<(i64, i64)> {
-        let mut it = vals.iter();
-        let first = it.next()?.as_i64_lossless()?;
+    fn scan_i64_min_max<P: Borrow<Prop>>(vals: impl IntoIterator<Item = P>) -> Option<(i64, i64)> {
+        let mut it = vals.into_iter();
+        let first = it.next()?.borrow().as_i64_lossless()?;
         let mut min_v = first;
         let mut max_v = first;
         for p in it {
+            let p = p.borrow();
             let x = p.as_i64_lossless()?;
             if x < min_v {
                 min_v = x;
@@ -84,10 +100,13 @@ pub fn aggregate_values(vals: &[Prop], op: Op) -> Option<Prop> {
         Some((min_v, max_v))
     }
 
-    fn scan_f64_sum_count(vals: &[Prop]) -> Option<(f64, u64)> {
+    fn scan_f64_sum_count<P: Borrow<Prop>>(
+        vals: impl IntoIterator<Item = P>,
+    ) -> Option<(f64, u64)> {
         let mut sum = 0.0f64;
         let mut count = 0u64;
         for p in vals {
+            let p = p.borrow();
             let x = p.as_f64_lossless()?;
             if !x.is_finite() {
                 return None;
@@ -98,15 +117,16 @@ pub fn aggregate_values(vals: &[Prop], op: Op) -> Option<Prop> {
         Some((sum, count))
     }
 
-    fn scan_f64_min_max(vals: &[Prop]) -> Option<(f64, f64)> {
-        let mut it = vals.iter();
-        let first = it.next()?.as_f64_lossless()?;
+    fn scan_f64_min_max<P: Borrow<Prop>>(vals: impl IntoIterator<Item = P>) -> Option<(f64, f64)> {
+        let mut it = vals.into_iter();
+        let first = it.next()?.borrow().as_f64_lossless()?;
         if !first.is_finite() {
             return None;
         }
         let mut min_v = first;
         let mut max_v = first;
         for p in it {
+            let p = p.borrow();
             let x = p.as_f64_lossless()?;
             if !x.is_finite() {
                 return None;
@@ -121,10 +141,14 @@ pub fn aggregate_values(vals: &[Prop], op: Op) -> Option<Prop> {
         Some((min_v, max_v))
     }
 
-    fn reduce_unsigned(vals: &[Prop], ret_minmax: fn(u64) -> Prop, op: Op) -> Option<Prop> {
+    fn reduce_unsigned<P: Borrow<Prop>>(
+        vals: impl IntoIterator<Item = P>,
+        ret_minmax: fn(u64) -> Prop,
+        op: Op,
+    ) -> Option<Prop> {
         match op {
             Op::Sum => {
-                let (promoted, s64, s128) = scan_u64_sum(vals)?;
+                let (promoted, s64, s128, _) = scan_u64_sum(vals)?;
                 Some(if promoted {
                     Prop::U64(u64::try_from(s128).ok()?)
                 } else {
@@ -132,8 +156,7 @@ pub fn aggregate_values(vals: &[Prop], op: Op) -> Option<Prop> {
                 })
             }
             Op::Avg => {
-                let (promoted, s64, s128) = scan_u64_sum(vals)?;
-                let count = vals.len() as u64;
+                let (promoted, s64, s128, count) = scan_u64_sum(vals)?;
                 let s = if promoted { s128 as f64 } else { s64 as f64 };
                 Some(Prop::F64(s / (count as f64)))
             }
@@ -143,10 +166,14 @@ pub fn aggregate_values(vals: &[Prop], op: Op) -> Option<Prop> {
         }
     }
 
-    fn reduce_signed(vals: &[Prop], ret_minmax: fn(i64) -> Prop, op: Op) -> Option<Prop> {
+    fn reduce_signed<P: Borrow<Prop>>(
+        vals: impl IntoIterator<Item = P>,
+        ret_minmax: fn(i64) -> Prop,
+        op: Op,
+    ) -> Option<Prop> {
         match op {
             Op::Sum => {
-                let (promoted, s64, s128) = scan_i64_sum(vals)?;
+                let (promoted, s64, s128, _) = scan_i64_sum(vals)?;
                 Some(if promoted {
                     Prop::I64(i64::try_from(s128).ok()?)
                 } else {
@@ -154,8 +181,7 @@ pub fn aggregate_values(vals: &[Prop], op: Op) -> Option<Prop> {
                 })
             }
             Op::Avg => {
-                let (promoted, s64, s128) = scan_i64_sum(vals)?;
-                let count = vals.len() as u64;
+                let (promoted, s64, s128, count) = scan_i64_sum(vals)?;
                 let s = if promoted { s128 as f64 } else { s64 as f64 };
                 Some(Prop::F64(s / (count as f64)))
             }
@@ -165,7 +191,11 @@ pub fn aggregate_values(vals: &[Prop], op: Op) -> Option<Prop> {
         }
     }
 
-    fn reduce_float(vals: &[Prop], ret_minmax: fn(f64) -> Prop, op: Op) -> Option<Prop> {
+    fn reduce_float<P: Borrow<Prop>>(
+        vals: impl IntoIterator<Item = P>,
+        ret_minmax: fn(f64) -> Prop,
+        op: Op,
+    ) -> Option<Prop> {
         match op {
             Op::Sum => scan_f64_sum_count(vals).map(|(sum, _)| Prop::F64(sum)),
             Op::Avg => {
@@ -179,12 +209,12 @@ pub fn aggregate_values(vals: &[Prop], op: Op) -> Option<Prop> {
     }
 
     match op {
-        Op::Len => Some(Prop::U64(vals.len() as u64)),
+        Op::Len => Some(Prop::U64(vals.count() as u64)),
         Op::Sum | Op::Avg | Op::Min | Op::Max => {
-            if vals.is_empty() {
+            if vals.peek().is_none() {
                 return None;
             }
-            let inner = vals[0].dtype();
+            let inner = vals.peek().unwrap().borrow().dtype();
             match inner {
                 PropType::U8 => reduce_unsigned(vals, |x| Prop::U8(x as u8), op),
                 PropType::U16 => reduce_unsigned(vals, |x| Prop::U16(x as u16), op),
@@ -209,7 +239,7 @@ pub fn apply_agg_to_prop(p: &Prop, op: Op) -> Option<Prop> {
         (Op::Sum, Prop::List(inner))
         | (Op::Avg, Prop::List(inner))
         | (Op::Min, Prop::List(inner))
-        | (Op::Max, Prop::List(inner)) => aggregate_values(inner.as_slice(), op),
+        | (Op::Max, Prop::List(inner)) => aggregate_values(inner.iter(), op),
 
         (Op::Len, _) => Some(Prop::U64(1)),
 
@@ -316,7 +346,7 @@ impl<M> PropertyFilter<M> {
         let (q, rest) = (quals[0], &quals[1..]);
 
         if let Prop::List(inner) = v {
-            let elems = inner.as_slice();
+            let mut elems = inner.iter().peekable();
             let check = |e: &Prop| {
                 if rest.is_empty() {
                     predicate(e)
@@ -325,8 +355,8 @@ impl<M> PropertyFilter<M> {
                 }
             };
             return match q {
-                Op::Any => elems.iter().any(check),
-                Op::All => !elems.is_empty() && elems.iter().all(check),
+                Op::Any => elems.any(|p| check(&p)),
+                Op::All => !elems.peek().is_none() && elems.all(|p| check(&p)),
                 _ => unreachable!(),
             };
         }
@@ -392,7 +422,7 @@ impl<M> PropertyFilter<M> {
                             ValueType::Scalar(reduce_over_seq(vs, *op))
                         }
                         ValueType::Scalar(Some(Prop::List(inner))) => {
-                            ValueType::Scalar(aggregate_values(inner.as_slice(), *op))
+                            ValueType::Scalar(aggregate_values(inner.iter(), *op))
                         }
                         ValueType::Scalar(Some(p)) => ValueType::Scalar(apply_agg_to_prop(&p, *op)),
                         ValueType::Scalar(None) => ValueType::Scalar(None),
@@ -497,7 +527,7 @@ impl<M> PropertyFilter<M> {
         }
 
         if let Some(seq) = maybe_seq {
-            let full = Prop::List(Arc::new(seq));
+            let full = Prop::List(seq.into());
             self.operator
                 .apply_to_property(&self.prop_value, Some(&full))
         } else {
diff --git a/raphtory/src/db/graph/views/filter/model/property_filter/mod.rs b/raphtory/src/db/graph/views/filter/model/property_filter/mod.rs
index 12c23b7bc7..4ff5123279 100644
--- a/raphtory/src/db/graph/views/filter/model/property_filter/mod.rs
+++ b/raphtory/src/db/graph/views/filter/model/property_filter/mod.rs
@@ -33,12 +33,12 @@ use raphtory_api::core::{
             meta::Meta,
             prop::{sort_comparable_props, Prop, PropType},
         },
-        EID,
+        LayerId, EID,
     },
     storage::timeindex::EventTime,
 };
 use raphtory_storage::graph::{
-    edges::{edge_ref::EdgeStorageRef, edge_storage_ops::EdgeStorageOps},
+    edges::{edge_ref::EdgeEntryRef, edge_storage_ops::EdgeStorageOps},
     nodes::{node_ref::NodeStorageRef, node_storage_ops::NodeStorageOps},
 };
 use std::{collections::HashSet, fmt, fmt::Display, sync::Arc};
@@ -327,7 +327,7 @@ impl<M> PropertyFilter<M> {
         &self,
         graph: &G,
         prop_id: usize,
-        edge: EdgeStorageRef,
+        edge: EdgeEntryRef,
     ) -> bool {
         let edge = EdgeView::new(graph, edge.out_ref());
         match self.prop_ref {
@@ -357,7 +357,7 @@ impl<M> PropertyFilter<M> {
         prop_id: usize,
         e: EID,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
     ) -> bool {
         let edge = EdgeView::new(graph, graph.core_edge(e).out_ref().at(t).at_layer(layer));
         match self.prop_ref {
diff --git a/raphtory/src/db/graph/views/filter/not_filtered_graph.rs b/raphtory/src/db/graph/views/filter/not_filtered_graph.rs
index 9ae3b351f3..bbfe681f15 100644
--- a/raphtory/src/db/graph/views/filter/not_filtered_graph.rs
+++ b/raphtory/src/db/graph/views/filter/not_filtered_graph.rs
@@ -12,14 +12,14 @@ use crate::{
 };
 use raphtory_api::{
     core::{
-        entities::{LayerIds, ELID},
+        entities::{LayerId, LayerIds, ELID},
         storage::timeindex::EventTime,
     },
     inherit::Base,
 };
 use raphtory_storage::{
     core_ops::InheritCoreGraphOps,
-    graph::{edges::edge_ref::EdgeStorageRef, nodes::node_ref::NodeStorageRef},
+    graph::{edges::edge_ref::EdgeEntryRef, nodes::node_ref::NodeStorageRef},
 };
 
 #[derive(Debug, Clone)]
@@ -76,7 +76,7 @@ impl<'graph, G: GraphViewOps<'graph>, T: GraphView> InternalEdgeLayerFilterOps
         false
     }
 
-    fn internal_filter_edge_layer(&self, edge: EdgeStorageRef, layer: usize) -> bool {
+    fn internal_filter_edge_layer(&self, edge: EdgeEntryRef, layer: LayerId) -> bool {
         self.graph.internal_filter_edge_layer(edge, layer) && {
             !self.filter.internal_edge_layer_filtered()
                 || !self.filter.internal_filter_edge_layer(edge, layer)
@@ -123,7 +123,7 @@ impl<'graph, G: GraphViewOps<'graph>, T: GraphView> InternalEdgeFilterOps
     }
 
     #[inline]
-    fn internal_filter_edge(&self, edge: EdgeStorageRef, layer_ids: &LayerIds) -> bool {
+    fn internal_filter_edge(&self, edge: EdgeEntryRef, layer_ids: &LayerIds) -> bool {
         self.graph.internal_filter_edge(edge, layer_ids) && {
             !self.filter.internal_edge_filtered()
                 || !self
diff --git a/raphtory/src/db/graph/views/filter/or_filtered_graph.rs b/raphtory/src/db/graph/views/filter/or_filtered_graph.rs
index 0bd0fe143c..db188d2085 100644
--- a/raphtory/src/db/graph/views/filter/or_filtered_graph.rs
+++ b/raphtory/src/db/graph/views/filter/or_filtered_graph.rs
@@ -11,14 +11,14 @@ use crate::{
 };
 use raphtory_api::{
     core::{
-        entities::{LayerIds, ELID},
+        entities::{LayerId, LayerIds, ELID},
         storage::timeindex::EventTime,
     },
     inherit::Base,
 };
 use raphtory_storage::{
     core_ops::InheritCoreGraphOps,
-    graph::{edges::edge_ref::EdgeStorageRef, nodes::node_ref::NodeStorageRef},
+    graph::{edges::edge_ref::EdgeEntryRef, nodes::node_ref::NodeStorageRef},
 };
 
 #[derive(Debug, Clone)]
@@ -79,7 +79,7 @@ impl<G, L: InternalEdgeLayerFilterOps, R: InternalEdgeLayerFilterOps> InternalEd
             && self.right.internal_layer_filter_edge_list_trusted()
     }
 
-    fn internal_filter_edge_layer(&self, edge: EdgeStorageRef, layer: usize) -> bool {
+    fn internal_filter_edge_layer(&self, edge: EdgeEntryRef, layer: LayerId) -> bool {
         self.left.internal_filter_edge_layer(edge, layer)
             || self.right.internal_filter_edge_layer(edge, layer)
     }
@@ -117,7 +117,7 @@ impl<G, L: InternalEdgeFilterOps, R: InternalEdgeFilterOps> InternalEdgeFilterOp
     }
 
     #[inline]
-    fn internal_filter_edge(&self, edge: EdgeStorageRef, layer_ids: &LayerIds) -> bool {
+    fn internal_filter_edge(&self, edge: EdgeEntryRef, layer_ids: &LayerIds) -> bool {
         self.left.internal_filter_edge(edge, layer_ids)
             || self.right.internal_filter_edge(edge, layer_ids)
     }
diff --git a/raphtory/src/db/graph/views/is_active_graph.rs b/raphtory/src/db/graph/views/is_active_graph.rs
index dba8fb8e5c..1b0b76faf3 100644
--- a/raphtory/src/db/graph/views/is_active_graph.rs
+++ b/raphtory/src/db/graph/views/is_active_graph.rs
@@ -13,8 +13,11 @@ use crate::{
     },
     prelude::GraphViewOps,
 };
-use raphtory_api::{core::entities::LayerIds, inherit::Base};
-use raphtory_storage::{core_ops::InheritCoreGraphOps, graph::edges::edge_ref::EdgeStorageRef};
+use raphtory_api::{
+    core::entities::{LayerId, LayerIds},
+    inherit::Base,
+};
+use raphtory_storage::{core_ops::InheritCoreGraphOps, graph::edges::edge_ref::EdgeEntryRef};
 
 #[derive(Copy, Clone, Debug)]
 pub struct IsActiveGraph<G> {
@@ -63,7 +66,7 @@ impl<'graph, G: GraphViewOps<'graph>> InternalEdgeLayerFilterOps for IsActiveGra
         false
     }
 
-    fn internal_filter_edge_layer(&self, edge: EdgeStorageRef, layer: usize) -> bool {
+    fn internal_filter_edge_layer(&self, edge: EdgeEntryRef, layer: LayerId) -> bool {
         let time_semantics = self.graph.edge_time_semantics();
         time_semantics.edge_is_active(edge, LayeredGraph::new(&self.graph, LayerIds::One(layer)))
             && self.graph.internal_filter_edge_layer(edge, layer)
diff --git a/raphtory/src/db/graph/views/is_deleted_graph.rs b/raphtory/src/db/graph/views/is_deleted_graph.rs
index 85da0a864e..320388c62c 100644
--- a/raphtory/src/db/graph/views/is_deleted_graph.rs
+++ b/raphtory/src/db/graph/views/is_deleted_graph.rs
@@ -13,8 +13,11 @@ use crate::{
     },
     prelude::GraphViewOps,
 };
-use raphtory_api::{core::entities::LayerIds, inherit::Base};
-use raphtory_storage::{core_ops::InheritCoreGraphOps, graph::edges::edge_ref::EdgeStorageRef};
+use raphtory_api::{
+    core::entities::{LayerId, LayerIds},
+    inherit::Base,
+};
+use raphtory_storage::{core_ops::InheritCoreGraphOps, graph::edges::edge_ref::EdgeEntryRef};
 
 #[derive(Copy, Clone, Debug)]
 pub struct IsDeletedGraph<G> {
@@ -63,7 +66,7 @@ impl<'graph, G: GraphViewOps<'graph>> InternalEdgeLayerFilterOps for IsDeletedGr
         false
     }
 
-    fn internal_filter_edge_layer(&self, edge: EdgeStorageRef, layer: usize) -> bool {
+    fn internal_filter_edge_layer(&self, edge: EdgeEntryRef, layer: LayerId) -> bool {
         let time_semantics = self.graph.edge_time_semantics();
         time_semantics.edge_is_deleted(edge, LayeredGraph::new(&self.graph, LayerIds::One(layer)))
             && self.graph.internal_filter_edge_layer(edge, layer)
diff --git a/raphtory/src/db/graph/views/is_self_loop_graph.rs b/raphtory/src/db/graph/views/is_self_loop_graph.rs
index bdce99263f..643463e424 100644
--- a/raphtory/src/db/graph/views/is_self_loop_graph.rs
+++ b/raphtory/src/db/graph/views/is_self_loop_graph.rs
@@ -13,7 +13,7 @@ use crate::{
 use raphtory_api::{core::entities::LayerIds, inherit::Base};
 use raphtory_storage::{
     core_ops::InheritCoreGraphOps,
-    graph::edges::{edge_ref::EdgeStorageRef, edge_storage_ops::EdgeStorageOps},
+    graph::edges::{edge_ref::EdgeEntryRef, edge_storage_ops::EdgeStorageOps},
 };
 
 #[derive(Copy, Clone, Debug)]
@@ -59,7 +59,7 @@ impl<'graph, G: GraphViewOps<'graph>> InternalEdgeFilterOps for IsSelfLoopGraph<
         false
     }
 
-    fn internal_filter_edge(&self, edge: EdgeStorageRef, layer_ids: &LayerIds) -> bool {
+    fn internal_filter_edge(&self, edge: EdgeEntryRef, layer_ids: &LayerIds) -> bool {
         edge.src() == edge.dst() && self.graph.internal_filter_edge(edge, layer_ids)
     }
 }
diff --git a/raphtory/src/db/graph/views/layer_graph.rs b/raphtory/src/db/graph/views/layer_graph.rs
index bd4d716aba..66b6560e09 100644
--- a/raphtory/src/db/graph/views/layer_graph.rs
+++ b/raphtory/src/db/graph/views/layer_graph.rs
@@ -4,15 +4,14 @@ use crate::{
         properties::internal::InheritPropertiesOps,
         view::internal::{
             GraphView, Immutable, InheritEdgeFilterOps, InheritEdgeHistoryFilter,
-            InheritExplodedEdgeFilterOps, InheritListOps, InheritMaterialize, InheritNodeFilterOps,
-            InheritNodeHistoryFilter, InheritStorageOps, InheritTimeSemantics,
-            InternalEdgeLayerFilterOps, InternalLayerOps, Static,
+            InheritEdgeLayerFilterOps, InheritExplodedEdgeFilterOps, InheritListOps,
+            InheritMaterialize, InheritNodeHistoryFilter, InheritStorageOps, InheritTimeSemantics,
+            InternalLayerOps, InternalNodeFilterOps, Static,
         },
     },
-    prelude::GraphViewOps,
 };
 use raphtory_api::inherit::Base;
-use raphtory_storage::{core_ops::InheritCoreGraphOps, graph::edges::edge_ref::EdgeStorageRef};
+use raphtory_storage::{core_ops::InheritCoreGraphOps, graph::nodes::node_ref::NodeStorageRef};
 use std::fmt::{Debug, Formatter};
 
 #[derive(Clone)]
@@ -23,11 +22,11 @@ pub struct LayeredGraph<G> {
     pub layers: LayerIds,
 }
 
-impl<'graph, G: GraphViewOps<'graph>> Immutable for LayeredGraph<G> {}
+impl<G: GraphView> Immutable for LayeredGraph<G> {}
 
 impl<G> Static for LayeredGraph<G> {}
 
-impl<'graph, G: GraphViewOps<'graph> + Debug> Debug for LayeredGraph<G> {
+impl<G: GraphView + Debug> Debug for LayeredGraph<G> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("LayeredGraph")
             .field("graph", &self.graph as &dyn Debug)
@@ -36,7 +35,7 @@ impl<'graph, G: GraphViewOps<'graph> + Debug> Debug for LayeredGraph<G> {
     }
 }
 
-impl<'graph, G: GraphViewOps<'graph>> Base for LayeredGraph<G> {
+impl<G: GraphView> Base for LayeredGraph<G> {
     type Base = G;
     #[inline(always)]
     fn base(&self) -> &Self::Base {
@@ -44,49 +43,62 @@ impl<'graph, G: GraphViewOps<'graph>> Base for LayeredGraph<G> {
     }
 }
 
-impl<'graph, G: GraphViewOps<'graph>> InheritTimeSemantics for LayeredGraph<G> {}
+impl<G: GraphView> InheritTimeSemantics for LayeredGraph<G> {}
 
-impl<'graph, G: GraphViewOps<'graph>> InheritListOps for LayeredGraph<G> {}
+impl<G: GraphView> InheritListOps for LayeredGraph<G> {}
 
-impl<'graph, G: GraphViewOps<'graph>> InheritCoreGraphOps for LayeredGraph<G> {}
+impl<G: GraphView> InheritCoreGraphOps for LayeredGraph<G> {}
 
-impl<'graph, G: GraphViewOps<'graph>> InheritMaterialize for LayeredGraph<G> {}
+impl<G: GraphView> InheritMaterialize for LayeredGraph<G> {}
 
-impl<'graph, G: GraphViewOps<'graph>> InheritPropertiesOps for LayeredGraph<G> {}
+impl<G: GraphView> InheritPropertiesOps for LayeredGraph<G> {}
 
-impl<'graph, G: GraphViewOps<'graph>> InheritStorageOps for LayeredGraph<G> {}
+impl<G: GraphView> InheritStorageOps for LayeredGraph<G> {}
 
-impl<'graph, G: GraphViewOps<'graph>> InheritNodeHistoryFilter for LayeredGraph<G> {}
+impl<G: GraphView> InheritNodeHistoryFilter for LayeredGraph<G> {}
 
-impl<'graph, G: GraphViewOps<'graph>> InheritEdgeHistoryFilter for LayeredGraph<G> {}
-impl<'graph, G: GraphView> InheritNodeFilterOps for LayeredGraph<G> {}
+impl<G: GraphView> InheritEdgeHistoryFilter for LayeredGraph<G> {}
+impl<G: GraphView> InternalNodeFilterOps for LayeredGraph<G> {
+    fn internal_nodes_filtered(&self) -> bool {
+        self.graph.internal_nodes_filtered()
+    }
 
-impl<'graph, G: GraphViewOps<'graph>> LayeredGraph<G> {
-    pub fn new(graph: G, layers: LayerIds) -> Self {
-        Self { graph, layers }
+    fn internal_node_list_trusted(&self) -> bool {
+        // after applying a layer, previously filtered lists can no longer be trusted
+        self.graph.internal_node_list_trusted() && self.layers.is_all()
     }
-}
 
-impl<'graph, G: GraphViewOps<'graph>> InternalLayerOps for LayeredGraph<G> {
-    fn layer_ids(&self) -> &LayerIds {
-        &self.layers
+    fn edge_filter_includes_node_filter(&self) -> bool {
+        self.graph.edge_filter_includes_node_filter()
+    }
+
+    fn edge_layer_filter_includes_node_filter(&self) -> bool {
+        self.graph.edge_layer_filter_includes_node_filter()
     }
-}
 
-impl<G: GraphView> InternalEdgeLayerFilterOps for LayeredGraph<G> {
-    fn internal_edge_layer_filtered(&self) -> bool {
-        !matches!(self.layers, LayerIds::All) || self.graph.internal_edge_layer_filtered()
+    fn exploded_edge_filter_includes_node_filter(&self) -> bool {
+        self.graph.exploded_edge_filter_includes_node_filter()
     }
 
-    fn internal_layer_filter_edge_list_trusted(&self) -> bool {
-        matches!(self.layers, LayerIds::All) && self.graph.internal_layer_filter_edge_list_trusted()
+    fn internal_filter_node(&self, node: NodeStorageRef, layer_ids: &LayerIds) -> bool {
+        self.graph.internal_filter_node(node, layer_ids)
     }
+}
 
-    fn internal_filter_edge_layer(&self, edge: EdgeStorageRef, layer: usize) -> bool {
-        self.graph.internal_filter_edge_layer(edge, layer) // actual layer filter handled upstream for optimisation
+impl<G: GraphView> LayeredGraph<G> {
+    pub fn new(graph: G, layers: LayerIds) -> Self {
+        Self { graph, layers }
     }
 }
 
+impl<G: GraphView> InternalLayerOps for LayeredGraph<G> {
+    fn layer_ids(&self) -> &LayerIds {
+        &self.layers
+    }
+}
+
+impl<G: GraphView> InheritEdgeLayerFilterOps for LayeredGraph<G> {}
+
 impl<G: GraphView> InheritEdgeFilterOps for LayeredGraph<G> {}
 
 impl<G: GraphView> InheritExplodedEdgeFilterOps for LayeredGraph<G> {}
diff --git a/raphtory/src/db/graph/views/node_subgraph.rs b/raphtory/src/db/graph/views/node_subgraph.rs
index 271f0b6204..74f69fa6a0 100644
--- a/raphtory/src/db/graph/views/node_subgraph.rs
+++ b/raphtory/src/db/graph/views/node_subgraph.rs
@@ -13,13 +13,16 @@ use crate::{
     prelude::GraphViewOps,
 };
 use raphtory_api::{
-    core::{entities::ELID, storage::timeindex::EventTime},
+    core::{
+        entities::{LayerId, ELID},
+        storage::timeindex::EventTime,
+    },
     inherit::Base,
 };
 use raphtory_storage::{
     core_ops::{CoreGraphOps, InheritCoreGraphOps},
     graph::{
-        edges::{edge_ref::EdgeStorageRef, edge_storage_ops::EdgeStorageOps},
+        edges::{edge_ref::EdgeEntryRef, edge_storage_ops::EdgeStorageOps},
         nodes::{node_ref::NodeStorageRef, node_storage_ops::NodeStorageOps},
     },
 };
@@ -115,7 +118,7 @@ impl<'graph, G: GraphViewOps<'graph>> InternalEdgeLayerFilterOps for NodeSubgrap
         false
     }
 
-    fn internal_filter_edge_layer(&self, edge: EdgeStorageRef, layer: usize) -> bool {
+    fn internal_filter_edge_layer(&self, edge: EdgeEntryRef, layer: LayerId) -> bool {
         self.graph.internal_filter_edge_layer(edge, layer)
     }
 
@@ -148,7 +151,7 @@ impl<'graph, G: GraphViewOps<'graph>> InternalEdgeFilterOps for NodeSubgraph<G>
     }
 
     #[inline]
-    fn internal_filter_edge(&self, edge: EdgeStorageRef, layer_ids: &LayerIds) -> bool {
+    fn internal_filter_edge(&self, edge: EdgeEntryRef, layer_ids: &LayerIds) -> bool {
         self.nodes.contains(&edge.src())
             && self.nodes.contains(&edge.dst())
             && self.graph.internal_filter_edge(edge, layer_ids)
diff --git a/raphtory/src/db/graph/views/valid_graph.rs b/raphtory/src/db/graph/views/valid_graph.rs
index 2602dbcd48..594eced410 100644
--- a/raphtory/src/db/graph/views/valid_graph.rs
+++ b/raphtory/src/db/graph/views/valid_graph.rs
@@ -13,8 +13,11 @@ use crate::{
     },
     prelude::GraphViewOps,
 };
-use raphtory_api::{core::entities::LayerIds, inherit::Base};
-use raphtory_storage::{core_ops::InheritCoreGraphOps, graph::edges::edge_ref::EdgeStorageRef};
+use raphtory_api::{
+    core::entities::{LayerId, LayerIds},
+    inherit::Base,
+};
+use raphtory_storage::{core_ops::InheritCoreGraphOps, graph::edges::edge_ref::EdgeEntryRef};
 
 #[derive(Copy, Clone, Debug)]
 pub struct ValidGraph<G> {
@@ -63,7 +66,7 @@ impl<'graph, G: GraphViewOps<'graph>> InternalEdgeLayerFilterOps for ValidGraph<
         false
     }
 
-    fn internal_filter_edge_layer(&self, edge: EdgeStorageRef, layer: usize) -> bool {
+    fn internal_filter_edge_layer(&self, edge: EdgeEntryRef, layer: LayerId) -> bool {
         let time_semantics = self.graph.edge_time_semantics();
         time_semantics.edge_is_valid(edge, LayeredGraph::new(&self.graph, LayerIds::One(layer)))
             && self.graph.internal_filter_edge_layer(edge, layer)
diff --git a/raphtory/src/db/graph/views/window_graph.rs b/raphtory/src/db/graph/views/window_graph.rs
index 81d7816396..6c14b0ed70 100644
--- a/raphtory/src/db/graph/views/window_graph.rs
+++ b/raphtory/src/db/graph/views/window_graph.rs
@@ -64,16 +64,16 @@ use raphtory_api::{
     core::{
         entities::{
             properties::prop::{Prop, PropType},
-            ELID,
+            LayerId, ELID,
         },
         storage::{arc_str::ArcStr, timeindex::EventTime},
     },
     inherit::Base,
-    iter::{BoxedLDIter, IntoDynDBoxed},
+    iter::IntoDynDBoxed,
 };
 use raphtory_storage::{
     core_ops::{CoreGraphOps, InheritCoreGraphOps},
-    graph::{edges::edge_ref::EdgeStorageRef, nodes::node_ref::NodeStorageRef},
+    graph::{edges::edge_ref::EdgeEntryRef, nodes::node_ref::NodeStorageRef},
 };
 use std::{
     fmt::{Debug, Formatter},
@@ -237,8 +237,8 @@ impl<'graph, G: GraphViewOps<'graph>> InternalNodeFilterOps for WindowedGraph<G>
 impl<'graph, G: GraphViewOps<'graph>> InternalTemporalPropertyViewOps for WindowedGraph<G> {
     fn dtype(&self, id: usize) -> PropType {
         self.graph
-            .graph_meta()
-            .temporal_mapper()
+            .graph_props_meta()
+            .temporal_prop_mapper()
             .get_dtype(id)
             .unwrap()
     }
@@ -258,8 +258,7 @@ impl<'graph, G: GraphViewOps<'graph>> InternalTemporalPropertyViewOps for Window
 
     fn temporal_iter_rev(&self, id: usize) -> BoxedLIter<'_, (EventTime, Prop)> {
         self.graph
-            .temporal_prop_iter_window(id, self.start_bound(), self.end_bound())
-            .rev()
+            .temporal_prop_iter_window_rev(id, self.start_bound(), self.end_bound())
             .into_dyn_boxed()
     }
 
@@ -342,7 +341,7 @@ impl<'graph, G: GraphViewOps<'graph>> GraphTimeSemanticsOps for WindowedGraph<G>
             .has_temporal_prop_window(prop_id, self.start_bound()..self.end_bound())
     }
 
-    fn temporal_prop_iter(&self, prop_id: usize) -> BoxedLDIter<'_, (EventTime, Prop)> {
+    fn temporal_prop_iter(&self, prop_id: usize) -> BoxedLIter<'_, (EventTime, Prop)> {
         if self.window_is_empty() {
             return iter::empty().into_dyn_dboxed();
         }
@@ -359,10 +358,20 @@ impl<'graph, G: GraphViewOps<'graph>> GraphTimeSemanticsOps for WindowedGraph<G>
         prop_id: usize,
         start: EventTime,
         end: EventTime,
-    ) -> BoxedLDIter<'_, (EventTime, Prop)> {
+    ) -> BoxedLIter<'_, (EventTime, Prop)> {
         self.graph.temporal_prop_iter_window(prop_id, start, end)
     }
 
+    fn temporal_prop_iter_window_rev(
+        &self,
+        prop_id: usize,
+        start: EventTime,
+        end: EventTime,
+    ) -> BoxedLIter<'_, (EventTime, Prop)> {
+        self.graph
+            .temporal_prop_iter_window_rev(prop_id, start, end)
+    }
+
     fn temporal_prop_last_at(&self, prop_id: usize, t: EventTime) -> Option<(EventTime, Prop)> {
         self.graph
             .temporal_prop_last_at_window(prop_id, t, self.window_bound())
@@ -390,7 +399,7 @@ impl<G: GraphView> InternalEdgeFilterOps for WindowedGraph<G> {
             || (!self.window_is_bounding() && self.graph.internal_edge_list_trusted())
     }
 
-    fn internal_filter_edge(&self, edge: EdgeStorageRef, layer_ids: &LayerIds) -> bool {
+    fn internal_filter_edge(&self, edge: EdgeEntryRef, layer_ids: &LayerIds) -> bool {
         self.graph.internal_filter_edge(edge, layer_ids)
     }
 
@@ -408,7 +417,7 @@ impl<G: GraphView> InternalEdgeLayerFilterOps for WindowedGraph<G> {
             || (!self.window_is_bounding() && self.graph.internal_layer_filter_edge_list_trusted())
     }
 
-    fn internal_filter_edge_layer(&self, edge: EdgeStorageRef, layer: usize) -> bool {
+    fn internal_filter_edge_layer(&self, edge: EdgeEntryRef, layer: LayerId) -> bool {
         self.graph.internal_filter_edge_layer(edge, layer)
     }
 
diff --git a/raphtory/src/db/task/context.rs b/raphtory/src/db/task/context.rs
index 43244d058d..2cf01959c8 100644
--- a/raphtory/src/db/task/context.rs
+++ b/raphtory/src/db/task/context.rs
@@ -1,14 +1,10 @@
 use super::task_state::{Global, Shard};
 use crate::{
-    core::{
-        entities::VID,
-        state::{
-            accumulator_id::AccId, agg::Accumulator, compute_state::ComputeState,
-            shuffle_state::ShuffleComputeState, StateType,
-        },
+    core::state::{
+        accumulator_id::AccId, agg::Accumulator, compute_state::ComputeState,
+        shuffle_state::ShuffleComputeState, StateType,
     },
-    db::{api::view::StaticGraphViewOps, graph::node::NodeView},
-    prelude::GraphViewOps,
+    db::api::view::StaticGraphViewOps,
 };
 use std::{fmt::Debug, sync::Arc};
 
@@ -31,20 +27,6 @@ where
     G: StaticGraphViewOps,
     CS: ComputeState,
 {
-    pub fn new_local_state<O: Debug + Default, F: Fn(NodeView<'static, G>) -> O>(
-        &self,
-        init_f: F,
-    ) -> Vec<O> {
-        let n = self.g.unfiltered_num_nodes();
-        let mut new_state = Vec::with_capacity(n);
-        for i in 0..n {
-            match self.g.node(VID(i)) {
-                Some(v) => new_state.push(init_f(v)),
-                None => new_state.push(O::default()),
-            }
-        }
-        new_state
-    }
     pub fn ss(&self) -> usize {
         self.ss
     }
diff --git a/raphtory/src/db/task/edge/eval_edge.rs b/raphtory/src/db/task/edge/eval_edge.rs
index ca0a1885e1..68ba9b9e56 100644
--- a/raphtory/src/db/task/edge/eval_edge.rs
+++ b/raphtory/src/db/task/edge/eval_edge.rs
@@ -5,20 +5,19 @@ use crate::{
     },
     db::{
         api::{
-            properties::Properties,
+            properties::{Metadata, Properties},
+            state::Index,
             view::{internal::InternalFilter, *},
         },
         graph::edge::EdgeView,
         task::{
+            edge::eval_edges::EvalEdges,
+            eval_graph::EvalGraph,
             node::{eval_node::EvalNodeView, eval_node_state::EVState},
             task_state::PrevLocalState,
         },
     },
 };
-
-use crate::db::task::edge::eval_edges::EvalEdges;
-
-use crate::db::{api::properties::Metadata, task::eval_graph::EvalGraph};
 use raphtory_storage::graph::graph::GraphStorage;
 use std::{cell::RefCell, rc::Rc};
 
@@ -26,6 +25,7 @@ pub struct EvalEdgeView<'graph, 'a, G, CS: Clone, S> {
     pub(crate) ss: usize,
     pub(crate) edge: EdgeView<G>,
     pub(crate) storage: &'graph GraphStorage,
+    pub(crate) index: &'graph Index<VID>,
     pub(crate) node_state: Rc<RefCell<EVState<'a, CS>>>,
     pub(crate) local_state_prev: &'graph PrevLocalState<'a, S>,
 }
@@ -37,6 +37,7 @@ impl<'graph, 'a: 'graph, G: GraphViewOps<'graph>, S, CS: ComputeState + 'a>
         ss: usize,
         edge: EdgeView<G>,
         storage: &'graph GraphStorage,
+        index: &'graph Index<VID>,
         node_state: Rc<RefCell<EVState<'a, CS>>>,
         local_state_prev: &'graph PrevLocalState<'a, S>,
     ) -> Self {
@@ -44,6 +45,7 @@ impl<'graph, 'a: 'graph, G: GraphViewOps<'graph>, S, CS: ComputeState + 'a>
             ss,
             edge,
             storage,
+            index,
             node_state,
             local_state_prev,
         }
@@ -93,9 +95,15 @@ impl<'graph, 'a: 'graph, G: GraphViewOps<'graph>, S: 'static, CS: ComputeState +
             storage,
             local_state_prev,
             node_state,
+            index: self.index,
         };
+        let state_pos = self
+            .index
+            .index(&node.node)
+            .unwrap_or_else(|| panic!("Internal Error, node {:?} needs to be in index", node.node));
         EvalNodeView {
             node: node.node,
+            state_pos,
             eval_graph,
             local_state: None,
         }
@@ -113,10 +121,12 @@ impl<'graph, 'a: 'graph, G: GraphViewOps<'graph>, S: 'static, CS: ComputeState +
         let node_state = self.node_state.clone();
         let local_state_prev = self.local_state_prev;
         let storage = self.storage;
+        let index = self.index;
         EvalEdges {
             ss,
             edges,
             storage,
+            index,
             node_state,
             local_state_prev,
         }
@@ -131,6 +141,7 @@ impl<'graph, 'a: 'graph, G: GraphViewOps<'graph>, S, CS: ComputeState + 'a> Clon
             ss: self.ss,
             edge: self.edge.clone(),
             storage: self.storage,
+            index: self.index,
             node_state: self.node_state.clone(),
             local_state_prev: self.local_state_prev,
         }
@@ -160,6 +171,7 @@ where
             self.ss,
             edge,
             self.storage,
+            self.index,
             self.node_state.clone(),
             self.local_state_prev,
         )
diff --git a/raphtory/src/db/task/edge/eval_edges.rs b/raphtory/src/db/task/edge/eval_edges.rs
index c069d02f74..00f53c53c6 100644
--- a/raphtory/src/db/task/edge/eval_edges.rs
+++ b/raphtory/src/db/task/edge/eval_edges.rs
@@ -6,6 +6,7 @@ use crate::{
     db::{
         api::{
             properties::{Metadata, Properties},
+            state::Index,
             view::{internal::InternalFilter, BaseEdgeViewOps, BoxedLIter},
         },
         graph::edges::Edges,
@@ -25,6 +26,7 @@ pub struct EvalEdges<'graph, 'a, G, CS: Clone, S> {
     pub(crate) ss: usize,
     pub(crate) edges: Edges<'graph, G>,
     pub(crate) storage: &'graph GraphStorage,
+    pub(crate) index: &'graph Index<VID>,
     pub(crate) node_state: Rc<RefCell<EVState<'a, CS>>>,
     pub(crate) local_state_prev: &'graph PrevLocalState<'a, S>,
 }
@@ -37,6 +39,7 @@ impl<'graph, 'a: 'graph, G: GraphViewOps<'graph>, CS: Clone, S> Clone
             ss: self.ss,
             edges: self.edges.clone(),
             storage: self.storage,
+            index: self.index,
             node_state: self.node_state.clone(),
             local_state_prev: self.local_state_prev,
         }
@@ -65,10 +68,12 @@ where
         let node_state = self.node_state.clone();
         let local_state_prev = self.local_state_prev;
         let storage = self.storage;
+        let index = self.index;
         EvalEdges {
             ss,
             edges,
             storage,
+            index,
             node_state,
             local_state_prev,
         }
@@ -83,6 +88,7 @@ impl<'graph, 'a, G: GraphViewOps<'graph>, CS: Clone + ComputeState, S>
         let ss = self.ss;
         let local_state_prev = self.local_state_prev;
         let storage = self.storage;
+        let index = self.index;
         self.edges
             .clone()
             .into_iter()
@@ -90,6 +96,7 @@ impl<'graph, 'a, G: GraphViewOps<'graph>, CS: Clone + ComputeState, S>
                 ss,
                 edge,
                 storage,
+                index,
                 node_state: node_state.clone(),
                 local_state_prev,
             })
@@ -107,10 +114,12 @@ impl<'graph, 'a, G: GraphViewOps<'graph>, CS: Clone + ComputeState, S> IntoItera
         let ss = self.ss;
         let local_state_prev = self.local_state_prev;
         let storage = self.storage;
+        let index = self.index;
         Box::new(self.edges.into_iter().map(move |edge| EvalEdgeView {
             ss,
             edge,
             storage,
+            index,
             node_state: node_state.clone(),
             local_state_prev,
         }))
@@ -154,10 +163,12 @@ impl<'graph, 'a, G: GraphViewOps<'graph>, CS: Clone + ComputeState, S: 'static>
         let path = self.edges.map_nodes(op);
         let base_graph = self.edges.base_graph.clone();
         let storage = self.storage;
+        let index = self.index;
         let eval_graph = EvalGraph {
             ss,
             base_graph,
             storage,
+            index,
             local_state_prev,
             node_state,
         };
@@ -179,9 +190,11 @@ impl<'graph, 'a, G: GraphViewOps<'graph>, CS: Clone + ComputeState, S: 'static>
         let local_state_prev = self.local_state_prev;
         let edges = self.edges.map_exploded(op);
         let storage = self.storage;
+        let index = self.index;
         Self {
             ss,
             storage,
+            index,
             node_state,
             local_state_prev,
             edges,
diff --git a/raphtory/src/db/task/eval_graph.rs b/raphtory/src/db/task/eval_graph.rs
index 5d2817a0f6..82653c5c3a 100644
--- a/raphtory/src/db/task/eval_graph.rs
+++ b/raphtory/src/db/task/eval_graph.rs
@@ -3,13 +3,17 @@ use crate::{
         entities::nodes::node_ref::AsNodeRef,
         state::compute_state::{ComputeState, ComputeStateVec},
     },
-    db::task::{
-        edge::eval_edge::EvalEdgeView,
-        node::{eval_node::EvalNodeView, eval_node_state::EVState},
-        task_state::PrevLocalState,
+    db::{
+        api::state::Index,
+        task::{
+            edge::eval_edge::EvalEdgeView,
+            node::{eval_node::EvalNodeView, eval_node_state::EVState},
+            task_state::PrevLocalState,
+        },
     },
     prelude::GraphViewOps,
 };
+use raphtory_core::entities::VID;
 use raphtory_storage::graph::graph::GraphStorage;
 use std::{cell::RefCell, rc::Rc};
 
@@ -20,6 +24,7 @@ pub struct EvalGraph<'graph, 'a, G, S, CS: Clone = ComputeStateVec> {
     pub(crate) storage: &'graph GraphStorage,
     pub(crate) local_state_prev: &'graph PrevLocalState<'a, S>,
     pub(crate) node_state: Rc<RefCell<EVState<'a, CS>>>,
+    pub(crate) index: &'graph Index<VID>,
 }
 
 impl<'graph, 'a, G: Clone, S, CS: Clone> Clone for EvalGraph<'graph, 'a, G, S, CS> {
@@ -30,6 +35,7 @@ impl<'graph, 'a, G: Clone, S, CS: Clone> Clone for EvalGraph<'graph, 'a, G, S, C
             storage: self.storage,
             local_state_prev: self.local_state_prev,
             node_state: self.node_state.clone(),
+            index: self.index,
         }
     }
 }
@@ -39,7 +45,15 @@ impl<'graph, 'a: 'graph, G: GraphViewOps<'graph>, S: 'static, CS: ComputeState +
 {
     pub fn node(&self, n: impl AsNodeRef) -> Option<EvalNodeView<'graph, 'a, G, S, CS>> {
         let node = (&self.base_graph).node(n)?;
-        Some(EvalNodeView::new_local(node.node, self.clone(), None))
+        let state_pos = self.index.index(&node.node).unwrap_or_else(|| {
+            panic!("Internal Error, node {:?} needs to be in index", node.node);
+        });
+        Some(EvalNodeView::new_local(
+            node.node,
+            state_pos,
+            self.clone(),
+            None,
+        ))
     }
 
     pub fn edge<N: AsNodeRef>(&self, src: N, dst: N) -> Option<EvalEdgeView<'graph, 'a, G, CS, S>> {
@@ -48,6 +62,7 @@ impl<'graph, 'a: 'graph, G: GraphViewOps<'graph>, S: 'static, CS: ComputeState +
             self.ss,
             edge.clone(),
             self.storage,
+            self.index,
             self.node_state.clone(),
             self.local_state_prev,
         ))
@@ -63,6 +78,7 @@ impl<'graph, 'a: 'graph, G: GraphViewOps<'graph>, S: 'static, CS: ComputeState +
             node_state: self.node_state.clone(),
             local_state_prev: self.local_state_prev,
             storage: self.storage,
+            index: self.index,
         }
     }
 }
diff --git a/raphtory/src/db/task/mod.rs b/raphtory/src/db/task/mod.rs
index 141ef726e9..025a1544ae 100644
--- a/raphtory/src/db/task/mod.rs
+++ b/raphtory/src/db/task/mod.rs
@@ -89,7 +89,7 @@ mod task_tests {
             vec![],
             vec![Job::new(step1)],
             None,
-            |egs, _, _, _| egs.finalize(&count),
+            |egs, _, _, _, _| egs.finalize(&count),
             Some(2),
             1,
             None,
diff --git a/raphtory/src/db/task/node/eval_node.rs b/raphtory/src/db/task/node/eval_node.rs
index 334a8f4d1c..5896cc64db 100644
--- a/raphtory/src/db/task/node/eval_node.rs
+++ b/raphtory/src/db/task/node/eval_node.rs
@@ -31,6 +31,7 @@ use std::{
 
 pub struct EvalNodeView<'graph, 'a: 'graph, G, S, CS: Clone = ComputeStateVec> {
     pub node: VID,
+    pub(crate) state_pos: usize,
     pub(crate) eval_graph: EvalGraph<'graph, 'a, G, S, CS>,
     pub(crate) local_state: Option<&'graph mut S>,
 }
@@ -40,11 +41,13 @@ impl<'graph, 'a: 'graph, G: GraphViewOps<'graph>, CS: ComputeState + 'a, S>
 {
     pub(crate) fn new_local(
         node: VID,
+        state_pos: usize,
         eval_graph: EvalGraph<'graph, 'a, G, S, CS>,
         local_state: Option<&'graph mut S>,
     ) -> Self {
         Self {
             node,
+            state_pos,
             eval_graph,
             local_state,
         }
@@ -57,6 +60,7 @@ impl<'graph, 'a: 'graph, G: GraphViewOps<'graph>, S, CS: ComputeState> Clone
     fn clone(&self) -> Self {
         Self {
             node: self.node,
+            state_pos: self.state_pos,
             eval_graph: self.eval_graph.clone(),
             local_state: None,
         }
@@ -71,8 +75,7 @@ impl<'graph, 'a: 'graph, G: GraphViewOps<'graph>, S, CS: ComputeState + 'a>
     }
 
     pub fn prev(&self) -> &S {
-        let VID(i) = self.node;
-        &self.eval_graph.local_state_prev.state[i]
+        &self.eval_graph.local_state_prev.state[self.state_pos]
     }
 
     pub fn get_mut(&mut self) -> &mut S {
@@ -91,21 +94,18 @@ impl<'graph, 'a: 'graph, G: GraphViewOps<'graph>, S, CS: ComputeState + 'a>
 
     pub(crate) fn new_filtered(
         node: VID,
+        state_pos: usize,
         eval_graph: EvalGraph<'graph, 'a, G, S, CS>,
         local_state: Option<&'graph mut S>,
     ) -> Self {
         Self {
             node,
+            state_pos,
             eval_graph,
             local_state,
         }
     }
 
-    fn pid(&self) -> usize {
-        let VID(i) = self.node;
-        i
-    }
-
     fn node_state(&self) -> Ref<'_, EVState<'a, CS>> {
         RefCell::borrow(&self.eval_graph.node_state)
     }
@@ -119,9 +119,12 @@ impl<'graph, 'a: 'graph, G: GraphViewOps<'graph>, S, CS: ComputeState + 'a>
         id: &AccId<A, IN, OUT, ACC>,
         a: IN,
     ) {
-        self.node_state_mut()
-            .shard_mut()
-            .accumulate_into(self.eval_graph.ss, self.pid(), a, id);
+        self.node_state_mut().shard_mut().accumulate_into(
+            self.eval_graph.ss,
+            self.state_pos,
+            a,
+            id,
+        );
     }
 
     pub fn global_update<A: StateType, IN: 'static, OUT: 'static, ACC: Accumulator<A, IN, OUT>>(
@@ -176,7 +179,7 @@ impl<'graph, 'a: 'graph, G: GraphViewOps<'graph>, S, CS: ComputeState + 'a>
     {
         self.node_state()
             .shard()
-            .read_with_pid(self.eval_graph.ss, self.pid(), agg_r)
+            .read_with_pid(self.eval_graph.ss, self.state_pos, agg_r)
             .unwrap_or(ACC::finish(&ACC::zero()))
     }
 
@@ -190,7 +193,12 @@ impl<'graph, 'a: 'graph, G: GraphViewOps<'graph>, S, CS: ComputeState + 'a>
         A: StateType,
         OUT: std::fmt::Debug,
     {
-        Entry::new(self.node_state(), *agg_r, &self.node, self.eval_graph.ss)
+        Entry::new(
+            self.node_state(),
+            *agg_r,
+            self.state_pos,
+            self.eval_graph.ss,
+        )
     }
 
     /// Read the prev value of the node state using the given accumulator.
@@ -205,7 +213,7 @@ impl<'graph, 'a: 'graph, G: GraphViewOps<'graph>, S, CS: ComputeState + 'a>
     {
         self.node_state()
             .shard()
-            .read_with_pid(self.eval_graph.ss + 1, self.pid(), agg_r)
+            .read_with_pid(self.eval_graph.ss + 1, self.state_pos, agg_r)
             .unwrap_or(ACC::finish(&ACC::zero()))
     }
 
@@ -238,8 +246,11 @@ impl<'graph, 'a: 'graph, G: GraphViewOps<'graph>, S, CS: ComputeState + 'a>
 
     pub fn iter(&self) -> impl Iterator<Item = EvalNodeView<'graph, 'a, G, S, CS>> + 'graph {
         let base_graph = self.eval_graph.clone();
-        self.iter_refs()
-            .map(move |v| EvalNodeView::new_filtered(v, base_graph.clone(), None))
+        let index = self.eval_graph.index;
+        self.iter_refs().map(move |v| {
+            let state_pos = index.index(&v).expect("VID not found in index");
+            EvalNodeView::new_filtered(v, state_pos, base_graph.clone(), None)
+        })
     }
 
     pub fn type_filter<I: IntoIterator<Item = V>, V: AsRef<str>>(&self, node_types: I) -> Self {
@@ -323,6 +334,7 @@ impl<'graph, 'a: 'graph, G: GraphViewOps<'graph>, S: 'static, CS: ComputeState +
         let storage = self.eval_graph.storage;
         let path =
             PathFromNode::new_one_hop_filtered(self.eval_graph.base_graph.clone(), self.op.clone());
+        let index = self.eval_graph.index;
         let edges = path.map_edges(op);
         EvalEdges {
             ss,
@@ -330,6 +342,7 @@ impl<'graph, 'a: 'graph, G: GraphViewOps<'graph>, S: 'static, CS: ComputeState +
             node_state,
             local_state_prev,
             storage,
+            index,
         }
     }
 
@@ -404,6 +417,7 @@ where
     ) -> Self::Filtered<Next> {
         EvalNodeView::new_filtered(
             self.node,
+            self.state_pos,
             self.eval_graph.apply_filter(filtered_graph),
             None,
         )
@@ -451,12 +465,14 @@ impl<'graph, 'a: 'graph, G: GraphView + 'graph, S: 'static, CS: ComputeState + '
             base_graph: self.eval_graph.base_graph.clone(),
             edges,
         };
+        let index = self.eval_graph.index;
         EvalEdges {
             ss,
             edges,
             node_state,
             local_state_prev,
             storage,
+            index,
         }
     }
 
@@ -486,7 +502,7 @@ impl<'graph, 'a: 'graph, G: GraphView + 'graph, S: 'static, CS: ComputeState + '
 pub struct Entry<'a, 'b, A: StateType, IN, OUT, ACC: Accumulator<A, IN, OUT>, CS: ComputeState> {
     state: Ref<'a, EVState<'b, CS>>,
     acc_id: AccId<A, IN, OUT, ACC>,
-    v_ref: &'a VID,
+    state_pos: usize,
     ss: usize,
 }
 
@@ -505,13 +521,13 @@ impl<'a, 'b, A: StateType, IN, OUT, ACC: Accumulator<A, IN, OUT>, CS: ComputeSta
     pub(crate) fn new(
         state: Ref<'a, EVState<'b, CS>>,
         acc_id: AccId<A, IN, OUT, ACC>,
-        v_ref: &'a VID,
+        state_pos: usize,
         ss: usize,
     ) -> Entry<'a, 'b, A, IN, OUT, ACC, CS> {
         Entry {
             state,
             acc_id,
-            v_ref,
+            state_pos,
             ss,
         }
     }
@@ -520,6 +536,6 @@ impl<'a, 'b, A: StateType, IN, OUT, ACC: Accumulator<A, IN, OUT>, CS: ComputeSta
     pub fn read_ref(&self) -> Option<&A> {
         self.state
             .shard()
-            .read_ref(self.ss, (*self.v_ref).into(), &self.acc_id)
+            .read_ref(self.ss, self.state_pos, &self.acc_id)
     }
 }
diff --git a/raphtory/src/db/task/task_runner.rs b/raphtory/src/db/task/task_runner.rs
index 90cec1a44a..ce5f07bd56 100644
--- a/raphtory/src/db/task/task_runner.rs
+++ b/raphtory/src/db/task/task_runner.rs
@@ -14,14 +14,14 @@ use crate::{
         },
     },
     db::{
-        api::view::StaticGraphViewOps,
+        api::{state::Index, view::StaticGraphViewOps},
         task::{
             eval_graph::EvalGraph,
             node::{eval_node::EvalNodeView, eval_node_state::EVState},
         },
     },
-    prelude::GraphViewOps,
 };
+use raphtory_api::atomic_extra::atomic_vid_from_mut_slice;
 use raphtory_storage::graph::graph::GraphStorage;
 use rayon::{prelude::*, ThreadPool};
 use std::{
@@ -55,7 +55,9 @@ impl<G: StaticGraphViewOps, CS: ComputeState> TaskRunner<G, CS> {
         global_state: &Global<CS>,
         morcel: &mut [S],
         prev_local_state: &Vec<S>,
+        reverse_vids: &Vec<VID>,
         storage: &GraphStorage,
+        index: &Index<VID>,
         atomic_done: &AtomicBool,
         morcel_size: usize,
         morcel_id: usize,
@@ -72,23 +74,25 @@ impl<G: StaticGraphViewOps, CS: ComputeState> TaskRunner<G, CS> {
         let mut v_ref = morcel_id * morcel_size;
 
         for local_state in morcel {
-            if g.has_node(VID(v_ref)) {
-                let eval_graph = EvalGraph {
-                    ss: self.ctx.ss(),
-                    base_graph: &g,
-                    storage,
-                    local_state_prev: &local,
-                    node_state: node_state.clone(),
-                };
-                let mut vv = EvalNodeView::new_local(v_ref.into(), eval_graph, Some(local_state));
+            let node = reverse_vids[v_ref];
+            // if g.has_node(VID(v_ref)) {
+            let eval_graph = EvalGraph {
+                ss: self.ctx.ss(),
+                base_graph: &g,
+                storage,
+                index,
+                local_state_prev: &local,
+                node_state: node_state.clone(),
+            };
+            let mut vv = EvalNodeView::new_local(node, v_ref, eval_graph, Some(local_state));
 
-                match task.run(&mut vv) {
-                    Step::Continue => {
-                        done = false;
-                    }
-                    Step::Done => {}
+            match task.run(&mut vv) {
+                Step::Continue => {
+                    done = false;
                 }
+                Step::Done => {}
             }
+            // }
             v_ref += 1;
         }
 
@@ -128,7 +132,9 @@ impl<G: StaticGraphViewOps, CS: ComputeState> TaskRunner<G, CS> {
         global_state: Global<CS>,
         mut local_state: Vec<S>,
         prev_local_state: &Vec<S>,
+        reverse_vids: &Vec<VID>,
         storage: &GraphStorage,
+        index: &Index<VID>,
     ) -> (bool, Shard<CS>, Global<CS>, Vec<S>) {
         pool.install(move || {
             let mut new_shard_state = shard_state;
@@ -149,7 +155,9 @@ impl<G: StaticGraphViewOps, CS: ComputeState> TaskRunner<G, CS> {
                                 &new_global_state,
                                 morcel,
                                 prev_local_state,
+                                reverse_vids,
                                 storage,
+                                index,
                                 &atomic_done,
                                 morcel_size,
                                 morcel_id,
@@ -167,7 +175,9 @@ impl<G: StaticGraphViewOps, CS: ComputeState> TaskRunner<G, CS> {
                                     &new_global_state,
                                     morcel,
                                     prev_local_state,
+                                    reverse_vids,
                                     storage,
+                                    index,
                                     &atomic_done,
                                     morcel_size,
                                     morcel_id,
@@ -202,19 +212,66 @@ impl<G: StaticGraphViewOps, CS: ComputeState> TaskRunner<G, CS> {
         })
     }
 
-    fn make_cur_and_prev_states<S: Clone + Default>(&self, mut init: Vec<S>) -> (Vec<S>, Vec<S>) {
-        let g = self.ctx.graph();
-        init.resize(g.unfiltered_num_nodes(), S::default());
+    fn make_cur_and_prev_states<S: Clone + Default>(
+        &self,
+        mut init: Vec<S>,
+        num_nodes: usize,
+    ) -> (Vec<S>, Vec<S>) {
+        init.resize(num_nodes, S::default());
 
         (init.clone(), init)
     }
 
     pub fn run<
         B,
-        F: FnOnce(GlobalState<CS>, EvalShardState<G, CS>, EvalLocalState<G, CS>, Vec<S>) -> B,
+        F: FnOnce(
+            GlobalState<CS>,
+            EvalShardState<G, CS>,
+            EvalLocalState<G, CS>,
+            Vec<S>,
+            Index<VID>,
+        ) -> B,
+        S: Send + Sync + Clone + 'static + std::fmt::Debug + Default,
+    >(
+        &mut self,
+        init_tasks: Vec<Job<G, CS, S>>,
+        tasks: Vec<Job<G, CS, S>>,
+        init: Option<Vec<S>>,
+        f: F,
+        num_threads: Option<usize>,
+        steps: usize,
+        shard_initial_state: Option<Shard<CS>>,
+        global_initial_state: Option<Global<CS>>,
+    ) -> B {
+        let node_index = Index::for_graph(self.ctx.graph());
+        self.run_with_index(
+            node_index,
+            init_tasks,
+            tasks,
+            init,
+            f,
+            num_threads,
+            steps,
+            shard_initial_state,
+            global_initial_state,
+        )
+    }
+
+    /// Execute tasks over nodes in `node_index`. Used for running algorithms over a super- or subset
+    /// of the nodes in the graph view.
+    pub fn run_with_index<
+        B,
+        F: FnOnce(
+            GlobalState<CS>,
+            EvalShardState<G, CS>,
+            EvalLocalState<G, CS>,
+            Vec<S>,
+            Index<VID>,
+        ) -> B,
         S: Send + Sync + Clone + 'static + std::fmt::Debug + Default,
     >(
         &mut self,
+        index: Index<VID>,
         init_tasks: Vec<Job<G, CS, S>>,
         tasks: Vec<Job<G, CS, S>>,
         init: Option<Vec<S>>,
@@ -226,8 +283,9 @@ impl<G: StaticGraphViewOps, CS: ComputeState> TaskRunner<G, CS> {
     ) -> B {
         let pool = num_threads.map(custom_pool).unwrap_or_else(|| POOL.clone());
 
-        let num_nodes = self.ctx.graph().unfiltered_num_nodes();
         let graph = self.ctx.graph();
+
+        let num_nodes = index.len();
         let storage = graph.core_graph();
         let morcel_size = num_nodes.min(16_000);
         let num_chunks = if morcel_size == 0 {
@@ -242,10 +300,19 @@ impl<G: StaticGraphViewOps, CS: ComputeState> TaskRunner<G, CS> {
         let mut global_state = global_initial_state.unwrap_or_else(|| Global::new());
 
         let (mut cur_local_state, mut prev_local_state) =
-            self.make_cur_and_prev_states::<S>(init.unwrap_or_default());
+            self.make_cur_and_prev_states::<S>(init.unwrap_or_default(), num_nodes);
 
         let mut _done = false;
 
+        let mut reverse_vids = vec![VID(0); index.len()];
+        {
+            let atom_vids = atomic_vid_from_mut_slice(&mut reverse_vids);
+
+            index.par_iter().for_each(|(i, vid)| {
+                atom_vids[i].store(vid.0, Ordering::Relaxed);
+            });
+        }
+
         (_done, shard_state, global_state, cur_local_state) = self.run_task_list(
             &init_tasks,
             &pool,
@@ -254,7 +321,9 @@ impl<G: StaticGraphViewOps, CS: ComputeState> TaskRunner<G, CS> {
             global_state,
             cur_local_state,
             &prev_local_state,
+            &reverse_vids,
             storage,
+            &index,
         );
 
         // To allow the init step to cache stuff we will copy everything from cur_local_state to prev_local_state
@@ -269,7 +338,9 @@ impl<G: StaticGraphViewOps, CS: ComputeState> TaskRunner<G, CS> {
                 global_state,
                 cur_local_state,
                 &prev_local_state,
+                &reverse_vids,
                 storage,
+                &index,
             );
 
             // copy and reset the state from the step that just ended
@@ -295,6 +366,7 @@ impl<G: StaticGraphViewOps, CS: ComputeState> TaskRunner<G, CS> {
             EvalShardState::new(ss, self.ctx.graph(), shard_state),
             EvalLocalState::new(ss, self.ctx.graph(), vec![]),
             last_local_state,
+            index,
         );
         self.ctx.reset_ss();
         to_return
diff --git a/raphtory/src/errors.rs b/raphtory/src/errors.rs
index 8d178e37ec..691a1df284 100644
--- a/raphtory/src/errors.rs
+++ b/raphtory/src/errors.rs
@@ -4,78 +4,68 @@ use crate::{
     core::storage::lazy_vec::IllegalSet,
     db::graph::views::filter::model::filter_operator::FilterOperator, prelude::GraphViewOps,
 };
+use arrow::{datatypes::DataType, error::ArrowError};
 use itertools::Itertools;
-use raphtory_api::core::{
-    entities::{
-        properties::prop::{PropError, PropType},
-        GID,
-    },
-    storage::timeindex::TimeError,
+use parquet::errors::ParquetError;
+use raphtory_api::core::entities::{
+    properties::prop::{InvalidPropertyTypeErr, PropError, PropType},
+    GidType, GID, VID,
 };
 use raphtory_core::entities::{
-    graph::{logical_to_physical::InvalidNodeId, tgraph::InvalidLayer},
+    graph::tgraph::InvalidLayer,
     properties::props::{MetadataError, TPropError},
 };
 use raphtory_storage::mutation::MutationError;
 use std::{
     fmt::Debug,
     io,
+    panic::Location,
     path::{PathBuf, StripPrefixError},
+    sync::Arc,
     time::SystemTimeError,
 };
 
-#[cfg(feature = "storage")]
-use pometry_storage::RAError;
-#[cfg(feature = "arrow")]
-use {
-    arrow::{datatypes::DataType, error::ArrowError},
-    parquet::errors::ParquetError,
-    raphtory_api::core::entities::{
-        properties::prop::{DeserialisationError, InvalidPropertyTypeErr},
-        GidType, VID,
-    },
-};
-
 #[cfg(feature = "python")]
 use pyo3::PyErr;
 use raphtory_api::core::utils::time::ParseTimeError;
 #[cfg(feature = "search")]
 use {tantivy, tantivy::query::QueryParserError};
 
+use raphtory_api::core::storage::timeindex::TimeError;
+use storage::{error::StorageError, resolver::mapping_resolver::InvalidNodeId};
+#[cfg(feature = "io")]
+use zip::result::ZipError;
+
 #[derive(thiserror::Error, Debug)]
 pub enum InvalidPathReason {
-    #[error("Backslash not allowed in path: {0}")]
-    BackslashError(PathBuf),
-    #[error("Double forward slashes are not allowed in path: {0}")]
-    DoubleForwardSlash(PathBuf),
-    #[error("Only relative paths are allowed to be used within the working_dir: {0}")]
-    RootNotAllowed(PathBuf),
-    #[error("References to the current dir are not allowed within the path: {0}")]
-    CurDirNotAllowed(PathBuf),
-    #[error("References to the parent dir are not allowed within the path: {0}")]
-    ParentDirNotAllowed(PathBuf),
-    #[error("A component of the given path was a symlink: {0}")]
-    SymlinkNotAllowed(PathBuf),
-    #[error("The give path does not exist: {0}")]
-    PathDoesNotExist(PathBuf),
-    #[error("Could not parse Path: {0}")]
-    PathNotParsable(PathBuf),
-    #[error("A component of the given path was hidden: {0}")]
-    HiddenPathNotAllowed(PathBuf),
-    #[error("The path to the graph contains a subpath to an existing graph: {0}")]
-    ParentIsGraph(PathBuf),
-    #[error("The path provided does not exists as a namespace: {0}")]
-    NamespaceDoesNotExist(String),
-    #[error("The path provided contains non-UTF8 characters.")]
-    NonUTFCharacters,
-    #[error("Failed to strip prefix")]
-    StripPrefix {
-        #[from]
-        source: StripPrefixError,
-    },
+    #[error("Backslash not allowed in path")]
+    BackslashError,
+    #[error("Double forward slashes are not allowed in path")]
+    DoubleForwardSlash,
+    #[error("Only relative paths are allowed to be used within the working_dir")]
+    RootNotAllowed,
+    #[error("References to the current dir are not allowed within the path")]
+    CurDirNotAllowed,
+    #[error("References to the parent dir are not allowed within the path")]
+    ParentDirNotAllowed,
+    #[error("A component of the given path was a symlink")]
+    SymlinkNotAllowed,
+    #[error("Could not parse Path")]
+    PathNotParsable,
+    #[error("A component of the given path was hidden")]
+    HiddenPathNotAllowed,
+    #[error("The path to the graph contains a subpath to an existing graph")]
+    ParentIsGraph,
+    #[error("Graph name cannot start with _")]
+    GraphNamePrefix,
+    #[error("The path provided already exists as a namespace")]
+    GraphIsNamespace,
+    #[error("The path provided already exists as a graph")]
+    NamespaceIsGraph,
+    #[error("Failed to strip prefix: {source}")]
+    StripPrefix { source: StripPrefixError },
 }
 
-#[cfg(feature = "arrow")]
 #[derive(thiserror::Error, Debug)]
 pub enum LoadError {
     #[error("Only str columns are supported for layers, got {0:?}")]
@@ -101,17 +91,16 @@ pub enum LoadError {
     MissingNodeError,
     #[error("Missing value for timestamp")]
     MissingTimeError,
+    #[error("Missing value for secondary index")]
+    MissingSecondaryIndexError,
     #[error("Missing value for edge id {0:?} -> {1:?}")]
     MissingEdgeError(VID, VID),
     #[error("Node IDs have the wrong type, expected {existing}, got {new}")]
     NodeIdTypeError { existing: GidType, new: GidType },
-    #[error("Fatal load error, graph may be in a dirty state.")]
-    FatalError,
     #[error("Arrow error: {0:?}")]
     Arrow(#[from] ArrowError),
 }
 
-#[cfg(feature = "arrow")]
 pub fn into_load_err(err: impl Into<LoadError>) -> LoadError {
     err.into()
 }
@@ -136,6 +125,9 @@ pub fn into_graph_err(err: impl Into<GraphError>) -> GraphError {
 
 #[derive(thiserror::Error, Debug)]
 pub enum GraphError {
+    #[error(transparent)]
+    ExternalError(Arc<dyn std::error::Error + Send + Sync>),
+
     #[error(transparent)]
     MutationError(#[from] MutationError),
 
@@ -145,11 +137,9 @@ pub enum GraphError {
     #[error("You cannot set ‘{0}’ and ‘{1}’ at the same time. Please pick one or the other.")]
     WrongNumOfArgs(String, String),
 
-    #[cfg(feature = "arrow")]
     #[error("Arrow-rs error: {0}")]
     ArrowRs(#[from] ArrowError),
 
-    #[cfg(feature = "arrow")]
     #[error("Arrow-rs parquet error: {0}")]
     ParquetError(#[from] ParquetError),
 
@@ -159,14 +149,17 @@ pub enum GraphError {
         source: InvalidPathReason,
     },
 
-    #[cfg(feature = "arrow")]
     #[error("{source}")]
     LoadError {
         #[from]
         source: LoadError,
     },
+
+    #[error("Path {0} does not exist")]
+    PathDoesNotExist(PathBuf),
+
     #[error("Storage feature not enabled")]
-    DiskGraphNotFound,
+    DiskGraphNotEnabled,
 
     #[error("Missing graph index. You need to create an index first.")]
     IndexNotCreated,
@@ -244,13 +237,14 @@ pub enum GraphError {
         src: String,
         dst: String,
     },
+
     #[error("The loaded graph is of the wrong type. Did you mean Graph / PersistentGraph?")]
     GraphLoadError,
 
-    #[error("IO operation failed")]
+    #[error("{source} at {location}")]
     IOError {
-        #[from]
         source: io::Error,
+        location: &'static Location<'static>,
     },
 
     #[error("IO operation failed: {0}")]
@@ -272,14 +266,22 @@ pub enum GraphError {
     #[error("The schema of the vector DB is invalid")]
     InvalidVectorDbSchema,
 
-    #[cfg(feature = "proto")]
+    #[cfg(feature = "io")]
     #[error("zip operation failed")]
     ZipError {
-        #[from]
         source: zip::result::ZipError,
+        location: &'static Location<'static>,
     },
 
-    #[cfg(feature = "arrow")]
+    #[error("Not a zip archive")]
+    NotAZip,
+
+    #[error("Not a disk graph")]
+    NotADiskGraph,
+
+    #[error("Graph folder is not initialised for writing")]
+    NoWriteInProgress,
+
     #[error("Failed to load graph: {0}")]
     LoadFailure(String),
 
@@ -288,10 +290,6 @@ pub enum GraphError {
     )]
     ColumnDoesNotExist(String),
 
-    #[cfg(feature = "storage")]
-    #[error("Raphtory Arrow Error: {0}")]
-    DiskGraphError(#[from] RAError),
-
     #[cfg(feature = "search")]
     #[error("Index operation failed: {source}")]
     IndexError {
@@ -358,14 +356,10 @@ pub enum GraphError {
     #[error("Protobuf decode error{0}")]
     EncodeError(#[from] prost::EncodeError),
 
-    #[cfg(feature = "proto")]
+    #[cfg(feature = "io")]
     #[error("Cannot write graph into non empty folder {0}")]
     NonEmptyGraphFolder(PathBuf),
 
-    #[cfg(feature = "arrow")]
-    #[error(transparent)]
-    DeserialisationError(#[from] DeserialisationError),
-
     #[cfg(feature = "proto")]
     #[error("Cache is not initialised")]
     CacheNotInnitialised,
@@ -473,8 +467,22 @@ pub enum GraphError {
     #[error("Your window and step must be of the same type: duration (string) or epoch (int)")]
     MismatchedIntervalTypes,
 
-    #[error("Cannot initialize cache for zipped graph. Unzip the graph to initialize the cache.")]
-    ZippedGraphCannotBeCached,
+    #[error("Cannot swap zipped graph data")]
+    ZippedGraphCannotBeSwapped,
+
+    #[error("{source} at {location}")]
+    StripPrefixError {
+        source: StripPrefixError,
+        location: &'static Location<'static>,
+    },
+    #[error("Path {0} is not a valid relative data path")]
+    InvalidRelativePath(String),
+
+    #[error(transparent)]
+    StorageError(#[from] StorageError),
+
+    #[error("Fatal write error: {0}")]
+    FatalWriteError(StorageError),
 }
 
 impl From<MetadataError> for GraphError {
@@ -525,14 +533,54 @@ impl From<GraphError> for io::Error {
     }
 }
 
-#[cfg(feature = "arrow")]
+impl From<io::Error> for GraphError {
+    #[track_caller]
+    fn from(source: io::Error) -> Self {
+        let location = Location::caller();
+        GraphError::IOError { source, location }
+    }
+}
+
+#[cfg(feature = "io")]
+impl From<ZipError> for GraphError {
+    #[track_caller]
+    fn from(source: ZipError) -> Self {
+        let location = Location::caller();
+        GraphError::ZipError { source, location }
+    }
+}
+
+impl From<StripPrefixError> for GraphError {
+    #[track_caller]
+    fn from(source: StripPrefixError) -> Self {
+        let location = Location::caller();
+        GraphError::StripPrefixError { source, location }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::errors::GraphError;
+    use std::io;
+
+    #[test]
+    fn test_location_capture() {
+        fn inner() -> Result<(), GraphError> {
+            Err(io::Error::other(GraphError::IllegalSet("hi".to_string())))?;
+            Ok(())
+        }
+
+        let res = inner().err().unwrap();
+        println!("{}", res);
+    }
+}
+
 impl From<InvalidPropertyTypeErr> for LoadError {
     fn from(value: InvalidPropertyTypeErr) -> Self {
         LoadError::InvalidPropertyType(value.0)
     }
 }
 
-#[cfg(feature = "arrow")]
 impl From<InvalidPropertyTypeErr> for GraphError {
     fn from(value: InvalidPropertyTypeErr) -> Self {
         GraphError::from(LoadError::from(value))
diff --git a/raphtory/src/graph_loader/company_house.rs b/raphtory/src/graph_loader/company_house.rs
index e123b56bae..f45964b0cd 100644
--- a/raphtory/src/graph_loader/company_house.rs
+++ b/raphtory/src/graph_loader/company_house.rs
@@ -84,6 +84,7 @@ pub fn company_house_graph(path: Option<String>) -> Graph {
                     owner.clone(),
                     NO_PROPS,
                     None,
+                    None,
                 )
                 .expect("Failed to add node")
                 .add_metadata([("type", "owner")])
@@ -94,6 +95,7 @@ pub fn company_house_graph(path: Option<String>) -> Graph {
                     company.clone(),
                     NO_PROPS,
                     None,
+                    None,
                 )
                 .expect("Failed to add node")
                 .add_metadata([
@@ -114,6 +116,7 @@ pub fn company_house_graph(path: Option<String>) -> Graph {
                     address.clone(),
                     NO_PROPS,
                     None,
+                    None,
                 )
                 .expect("Failed to add node")
                 .add_metadata([
diff --git a/raphtory/src/graph_loader/karate_club.rs b/raphtory/src/graph_loader/karate_club.rs
index abb187b5ec..83fbf27dba 100644
--- a/raphtory/src/graph_loader/karate_club.rs
+++ b/raphtory/src/graph_loader/karate_club.rs
@@ -68,7 +68,7 @@ pub fn karate_club_graph() -> Graph {
     let graph = Graph::new();
     for i in 0..34 {
         graph
-            .add_node(0, i, NO_PROPS, None)
+            .add_node(0, i, NO_PROPS, None, None)
             .map_err(|err| error!("{:?}", err))
             .ok();
     }
diff --git a/raphtory/src/graph_loader/lotr_graph.rs b/raphtory/src/graph_loader/lotr_graph.rs
index 1746fd0352..875f440d3c 100644
--- a/raphtory/src/graph_loader/lotr_graph.rs
+++ b/raphtory/src/graph_loader/lotr_graph.rs
@@ -85,10 +85,10 @@ pub fn lotr_graph() -> Graph {
             let dst_id = lotr.dst_id;
             let time = lotr.time;
 
-            g.add_node(time, src_id.clone(), NO_PROPS, None)
+            g.add_node(time, src_id.clone(), NO_PROPS, None, None)
                 .map_err(|err| error!("{:?}", err))
                 .ok();
-            g.add_node(time, dst_id.clone(), NO_PROPS, None)
+            g.add_node(time, dst_id.clone(), NO_PROPS, None, None)
                 .map_err(|err| error!("{:?}", err))
                 .ok();
             g.add_edge(time, src_id.clone(), dst_id.clone(), NO_PROPS, None)
diff --git a/raphtory/src/graph_loader/mod.rs b/raphtory/src/graph_loader/mod.rs
index 02a786e311..dadcd06e85 100644
--- a/raphtory/src/graph_loader/mod.rs
+++ b/raphtory/src/graph_loader/mod.rs
@@ -53,7 +53,7 @@
 //!         lotr.time,
 //!         lotr.src_id.clone(),
 //!         [("type", Prop::str("Character"))],
-//!         None,
+//!         None, None
 //!     )
 //!     .expect("Failed to add node");
 //!
@@ -61,7 +61,7 @@
 //!         lotr.time,
 //!         lotr.dst_id.clone(),
 //!         [("type", Prop::str("Character"))],
-//!         None
+//!         None, None
 //!     )
 //!     .expect("Failed to add node");
 //!
@@ -227,9 +227,9 @@ mod graph_loader_test {
                     let src_id = src.id();
                     let dst_id = dst.id();
 
-                    g.add_node(t, src_id, [("name", Prop::str("Character"))], None)
+                    g.add_node(t, src_id, [("name", Prop::str("Character"))], None, None)
                         .unwrap();
-                    g.add_node(t, dst_id, [("name", Prop::str("Character"))], None)
+                    g.add_node(t, dst_id, [("name", Prop::str("Character"))], None, None)
                         .unwrap();
                     g.add_edge(
                         t,
diff --git a/raphtory/src/graph_loader/neo4j_examples.rs b/raphtory/src/graph_loader/neo4j_examples.rs
index 963144f173..c59a1359a1 100644
--- a/raphtory/src/graph_loader/neo4j_examples.rs
+++ b/raphtory/src/graph_loader/neo4j_examples.rs
@@ -19,12 +19,12 @@ fn load_movies(row: Row, graph: &rap::Graph) {
     let relation_type = relation.typ();
 
     graph
-        .add_node(actor_born, actor_name.clone(), NO_PROPS, None)
+        .add_node(actor_born, actor_name.clone(), NO_PROPS, None, None)
         .unwrap()
         .add_metadata([("type", "actor")])
         .unwrap();
     graph
-        .add_node(film_release, film_title.clone(), NO_PROPS, None)
+        .add_node(film_release, film_title.clone(), NO_PROPS, None, None)
         .unwrap()
         .add_metadata([
             ("type", "film".into_prop()),
diff --git a/raphtory/src/graph_loader/reddit_hyperlinks.rs b/raphtory/src/graph_loader/reddit_hyperlinks.rs
index 1091e57466..64cc1f86ac 100644
--- a/raphtory/src/graph_loader/reddit_hyperlinks.rs
+++ b/raphtory/src/graph_loader/reddit_hyperlinks.rs
@@ -137,10 +137,10 @@ pub fn generate_reddit_graph(path: PathBuf) -> Graph {
                             Prop::F64(post_properties[20]),
                         ),
                     ];
-                    g.add_node(time, *src_id, NO_PROPS, None)
+                    g.add_node(time, *src_id, NO_PROPS, None, None)
                         .map_err(|err| error!("{:?}", err))
                         .ok();
-                    g.add_node(time, *dst_id, NO_PROPS, None)
+                    g.add_node(time, *dst_id, NO_PROPS, None, None)
                         .map_err(|err| error!("{:?}", err))
                         .ok();
                     g.add_edge(time, *src_id, *dst_id, edge_properties, None)
diff --git a/raphtory/src/graphgen/erdos_renyi.rs b/raphtory/src/graphgen/erdos_renyi.rs
index 9edbda03a1..433cfa44ea 100644
--- a/raphtory/src/graphgen/erdos_renyi.rs
+++ b/raphtory/src/graphgen/erdos_renyi.rs
@@ -51,19 +51,19 @@ pub fn erdos_renyi(nodes_to_add: usize, p: f64, seed: Option<u64>) -> Result<Gra
     if let Some(seed_value) = seed {
         rng = StdRng::seed_from_u64(seed_value);
     } else {
-        rng = StdRng::from_entropy();
+        rng = StdRng::from_os_rng();
     }
     let mut latest_time = graph.latest_time().map_or(0, |t| t.t());
     for i in 0..nodes_to_add {
         let id = GID::U64(i as u64);
         latest_time += 1;
-        graph.add_node(latest_time, &id, NO_PROPS, None)?;
+        graph.add_node(latest_time, &id, NO_PROPS, None, None)?;
     }
     for i in 0..nodes_to_add {
         let source_id = GID::U64(i as u64);
         for j in (i + 1)..nodes_to_add {
             let dst_id = GID::U64(j as u64);
-            let create_edge = rng.gen_bool(p);
+            let create_edge = rng.random_bool(p);
             if create_edge {
                 latest_time += 1;
                 graph.add_edge(latest_time, &source_id, &dst_id, NO_PROPS, None)?;
@@ -76,11 +76,7 @@ pub fn erdos_renyi(nodes_to_add: usize, p: f64, seed: Option<u64>) -> Result<Gra
 
 #[cfg(test)]
 mod tests {
-    use crate::{
-        db::api::view::{graph::GraphViewOps, node::NodeViewOps},
-        graphgen::erdos_renyi::erdos_renyi,
-        prelude::NodeStateOps,
-    };
+    use crate::{graphgen::erdos_renyi::erdos_renyi, prelude::*};
 
     #[test]
     fn test_erdos_renyi_half_probability() {
diff --git a/raphtory/src/graphgen/mod.rs b/raphtory/src/graphgen/mod.rs
index 072006dc02..67d499eb95 100644
--- a/raphtory/src/graphgen/mod.rs
+++ b/raphtory/src/graphgen/mod.rs
@@ -14,9 +14,9 @@ pub(crate) fn next_id<'graph, G: GraphViewOps<'graph>>(g: &G, max_gid: Option<GI
     match max_gid {
         GID::U64(id) => GID::U64(id + 1),
         GID::Str(_) => {
-            let mut rng = rand::thread_rng();
+            let mut rng = rand::rng();
             loop {
-                let new_id = GID::Str(rng.gen::<u64>().to_string());
+                let new_id = GID::Str(rng.random::<u64>().to_string());
                 if g.node(&new_id).is_none() {
                     break new_id;
                 }
diff --git a/raphtory/src/graphgen/preferential_attachment.rs b/raphtory/src/graphgen/preferential_attachment.rs
index c277e5f56e..b40d30feb4 100644
--- a/raphtory/src/graphgen/preferential_attachment.rs
+++ b/raphtory/src/graphgen/preferential_attachment.rs
@@ -62,7 +62,7 @@ pub fn ba_preferential_attachment(
     if let Some(seed_value) = seed {
         rng = StdRng::from_seed(seed_value);
     } else {
-        rng = StdRng::from_entropy();
+        rng = StdRng::from_os_rng();
     }
     let mut latest_time = graph.latest_time().map_or(0, |t| t.t());
     let view = graph;
@@ -75,7 +75,7 @@ pub fn ba_preferential_attachment(
     while ids.len() < edges_per_step {
         max_id = next_id(view, Some(max_id));
         graph
-            .add_node(latest_time, &max_id, NO_PROPS, None)
+            .add_node(latest_time, &max_id, NO_PROPS, None, None)
             .map_err(|err| error!("{:?}", err))
             .ok();
         degrees.push(0);
@@ -101,7 +101,7 @@ pub fn ba_preferential_attachment(
 
         for _ in 0..edges_per_step {
             let mut sum = 0;
-            let rand_num = rng.gen_range(1..=normalisation);
+            let rand_num = rng.random_range(1..=normalisation);
             for pos in 0..ids.len() {
                 if !positions_to_skip.contains(&pos) {
                     sum += degrees[pos];
@@ -146,7 +146,7 @@ mod preferential_attachment_tests {
         let graph = Graph::new();
         for i in 0..10 {
             graph
-                .add_node(i, i as u64, NO_PROPS, None)
+                .add_node(i, i as u64, NO_PROPS, None, None)
                 .map_err(|err| error!("{:?}", err))
                 .ok();
         }
diff --git a/raphtory/src/graphgen/random_attachment.rs b/raphtory/src/graphgen/random_attachment.rs
index 1db39ca4a6..d3d34c982e 100644
--- a/raphtory/src/graphgen/random_attachment.rs
+++ b/raphtory/src/graphgen/random_attachment.rs
@@ -21,7 +21,7 @@ use crate::{
     },
     prelude::{NodeStateOps, NO_PROPS},
 };
-use rand::{rngs::StdRng, seq::SliceRandom, SeedableRng};
+use rand::{prelude::IndexedRandom, rngs::StdRng, SeedableRng};
 use raphtory_api::core::storage::timeindex::AsTime;
 use tracing::error;
 
@@ -58,7 +58,7 @@ pub fn random_attachment(
     if let Some(seed_value) = seed {
         rng = StdRng::from_seed(seed_value);
     } else {
-        rng = StdRng::from_entropy();
+        rng = StdRng::from_os_rng();
     }
     let mut latest_time = graph.latest_time().map_or(0, |t| t.t());
     let mut ids = graph.nodes().id().iter_values().collect::<Vec<_>>();
@@ -68,7 +68,7 @@ pub fn random_attachment(
         max_id = next_id(graph, Some(max_id));
         latest_time += 1;
         graph
-            .add_node(latest_time, &max_id, NO_PROPS, None)
+            .add_node(latest_time, &max_id, NO_PROPS, None, None)
             .map_err(|err| error!("{:?}", err))
             .ok();
         ids.push(max_id.clone());
@@ -106,7 +106,7 @@ mod random_graph_test {
         let graph = Graph::new();
         for i in 0..10 {
             graph
-                .add_node(i, i as u64, NO_PROPS, None)
+                .add_node(i, i as u64, NO_PROPS, None, None)
                 .map_err(|err| error!("{:?}", err))
                 .ok();
         }
diff --git a/raphtory/src/io/arrow/dataframe.rs b/raphtory/src/io/arrow/dataframe.rs
index 8acfe137d1..74d75a5e3d 100644
--- a/raphtory/src/io/arrow/dataframe.rs
+++ b/raphtory/src/io/arrow/dataframe.rs
@@ -6,12 +6,16 @@ use crate::{
 use arrow::{
     array::{cast::AsArray, Array, ArrayRef, PrimitiveArray},
     compute::cast,
-    datatypes::{DataType, Date64Type, Int64Type, TimeUnit, TimestampMillisecondType},
+    datatypes::{DataType, Date64Type, Int64Type, TimeUnit, TimestampMillisecondType, UInt64Type},
 };
+use either::Either;
 use itertools::Itertools;
 use raphtory_api::core::storage::timeindex::AsTime;
 use rayon::prelude::*;
-use std::fmt::{Debug, Formatter};
+use std::{
+    fmt::{Debug, Formatter},
+    ops::{Deref, Range},
+};
 
 pub struct DFView<I> {
     pub names: Vec<String>,
@@ -34,10 +38,7 @@ impl<I> Debug for DFView<I> {
     }
 }
 
-impl<I, E> DFView<I>
-where
-    I: Iterator<Item = Result<DFChunk, E>>,
-{
+impl<I> DFView<I> {
     pub fn check_cols_exist(&self, cols: &[&str]) -> Result<(), GraphError> {
         let non_cols: Vec<&&str> = cols
             .iter()
@@ -51,15 +52,17 @@ where
     }
 
     pub(crate) fn get_index(&self, name: &str) -> Result<usize, GraphError> {
-        self.names
-            .iter()
-            .position(|n| n == name)
+        self.get_index_opt(name)
             .ok_or_else(|| GraphError::ColumnDoesNotExist(name.to_string()))
     }
 
+    pub(crate) fn get_index_opt(&self, name: &str) -> Option<usize> {
+        self.names.iter().position(|n| n == name)
+    }
+
     /// Returns Some(_) only if we know the total number of rows.
-    pub fn is_empty(&self) -> Option<bool> {
-        self.num_rows.map(|x| x == 0)
+    pub fn is_empty(&self) -> bool {
+        self.num_rows.is_some_and(|num_rows| num_rows == 0)
     }
 
     pub fn new(names: Vec<String>, chunks: I, num_rows: Option<usize>) -> Self {
@@ -143,6 +146,74 @@ impl TimeCol {
     pub fn get(&self, i: usize) -> Option<i64> {
         (i < self.0.len()).then(|| self.0.value(i))
     }
+
+    pub fn values(&self) -> &[i64] {
+        self.0.values()
+    }
+}
+
+impl Deref for TimeCol {
+    type Target = [i64];
+
+    fn deref(&self) -> &Self::Target {
+        self.0.values()
+    }
+}
+
+pub enum SecondaryIndexCol {
+    DataFrame(PrimitiveArray<UInt64Type>),
+    Range(Range<usize>),
+}
+
+impl SecondaryIndexCol {
+    /// Load a secondary index column from a dataframe.
+    pub fn new_from_df(arr: &dyn Array) -> Result<Self, LoadError> {
+        if arr.null_count() > 0 {
+            return Err(LoadError::MissingSecondaryIndexError);
+        }
+
+        Ok(SecondaryIndexCol::DataFrame(
+            arr.as_primitive::<UInt64Type>().clone(),
+        ))
+    }
+
+    /// Generate a secondary index column with values from `start` to `end` (not inclusive).
+    pub fn new_from_range(start: usize, end: usize) -> Self {
+        let start = start;
+        let end = end;
+        SecondaryIndexCol::Range(start..end)
+    }
+
+    pub fn par_iter(&self) -> impl IndexedParallelIterator<Item = usize> + '_ {
+        match self {
+            SecondaryIndexCol::DataFrame(arr) => {
+                rayon::iter::Either::Left(arr.values().par_iter().copied().map(|v| v as usize))
+            }
+            SecondaryIndexCol::Range(range) => {
+                rayon::iter::Either::Right(range.clone().into_par_iter())
+            }
+        }
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = usize> + '_ {
+        match self {
+            SecondaryIndexCol::DataFrame(arr) => {
+                Either::Left(arr.values().iter().copied().map(|v| v as usize))
+            }
+            SecondaryIndexCol::Range(range) => Either::Right(range.clone()),
+        }
+    }
+
+    pub fn max(&self) -> usize {
+        self.iter().max().unwrap_or(0)
+    }
+
+    pub fn len(&self) -> usize {
+        match self {
+            SecondaryIndexCol::DataFrame(arr) => arr.len(),
+            SecondaryIndexCol::Range(range) => range.len(),
+        }
+    }
 }
 
 #[derive(Clone, Debug)]
@@ -159,6 +230,10 @@ impl DFChunk {
         self.chunk.first().map(|c| c.len()).unwrap_or(0)
     }
 
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
     pub fn node_col(&self, index: usize) -> Result<NodeCol, LoadError> {
         lift_node_col(index, self)
     }
@@ -166,4 +241,15 @@ impl DFChunk {
     pub fn time_col(&self, index: usize) -> Result<TimeCol, LoadError> {
         TimeCol::new(self.chunk[index].as_ref())
     }
+
+    pub fn secondary_index_col(&self, index: usize) -> Result<SecondaryIndexCol, LoadError> {
+        SecondaryIndexCol::new_from_df(self.chunk[index].as_ref())
+    }
+
+    pub fn size(&self) -> usize {
+        self.chunk
+            .iter()
+            .map(|arr| arr.get_array_memory_size())
+            .sum()
+    }
 }
diff --git a/raphtory/src/io/arrow/df_loaders.rs b/raphtory/src/io/arrow/df_loaders.rs
deleted file mode 100644
index 964c886d01..0000000000
--- a/raphtory/src/io/arrow/df_loaders.rs
+++ /dev/null
@@ -1,889 +0,0 @@
-use crate::{
-    core::entities::{nodes::node_ref::AsNodeRef, LayerIds},
-    db::api::view::StaticGraphViewOps,
-    errors::{into_graph_err, GraphError, LoadError},
-    io::arrow::{
-        dataframe::{DFChunk, DFView},
-        layer_col::{lift_layer_col, lift_node_type_col},
-        prop_handler::*,
-    },
-    prelude::*,
-    serialise::incremental::InternalCache,
-};
-use bytemuck::checked::cast_slice_mut;
-#[cfg(feature = "python")]
-use kdam::{Bar, BarBuilder, BarExt};
-use raphtory_api::{
-    atomic_extra::atomic_usize_from_mut_slice,
-    core::{
-        entities::{properties::prop::PropType, EID},
-        storage::{dict_mapper::MaybeNew, timeindex::EventTime},
-        Direction,
-    },
-};
-use rayon::prelude::*;
-use std::{collections::HashMap, sync::atomic::Ordering};
-
-#[cfg(feature = "python")]
-fn build_progress_bar(des: String, num_rows: Option<usize>) -> Result<Bar, GraphError> {
-    if let Some(num_rows) = num_rows {
-        BarBuilder::default()
-            .desc(des)
-            .animation(kdam::Animation::FillUp)
-            .total(num_rows)
-            .unit_scale(true)
-            .build()
-            .map_err(|_| GraphError::TqdmError)
-    } else {
-        BarBuilder::default()
-            .desc(des)
-            .animation(kdam::Animation::FillUp)
-            .unit_scale(true)
-            .build()
-            .map_err(|_| GraphError::TqdmError)
-    }
-}
-
-fn process_shared_properties(
-    props: Option<&HashMap<String, Prop>>,
-    resolver: impl Fn(&str, PropType) -> Result<MaybeNew<usize>, GraphError>,
-) -> Result<Vec<(usize, Prop)>, GraphError> {
-    match props {
-        None => Ok(vec![]),
-        Some(props) => props
-            .iter()
-            .map(|(key, prop)| Ok((resolver(key, prop.dtype())?.inner(), prop.clone())))
-            .collect(),
-    }
-}
-
-pub(crate) fn load_nodes_from_df<
-    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps + InternalCache,
->(
-    df_view: DFView<impl Iterator<Item = Result<DFChunk, GraphError>>>,
-    time: &str,
-    node_id: &str,
-    properties: &[&str],
-    metadata: &[&str],
-    shared_metadata: Option<&HashMap<String, Prop>>,
-    node_type: Option<&str>,
-    node_type_col: Option<&str>,
-    graph: &G,
-) -> Result<(), GraphError> {
-    if matches!(df_view.is_empty(), Some(true)) {
-        return Ok(());
-    }
-    let properties_indices = properties
-        .iter()
-        .map(|name| df_view.get_index(name))
-        .collect::<Result<Vec<_>, GraphError>>()?;
-    let metadata_indices = metadata
-        .iter()
-        .map(|name| df_view.get_index(name))
-        .collect::<Result<Vec<_>, GraphError>>()?;
-
-    let node_type_index =
-        node_type_col.map(|node_type_col| df_view.get_index(node_type_col.as_ref()));
-    let node_type_index = node_type_index.transpose()?;
-
-    let node_id_index = df_view.get_index(node_id)?;
-    let time_index = df_view.get_index(time)?;
-
-    let shared_metadata = process_shared_properties(shared_metadata, |key, dtype| {
-        graph
-            .resolve_node_property(key, dtype, true)
-            .map_err(into_graph_err)
-    })?;
-
-    #[cfg(feature = "python")]
-    let mut pb = build_progress_bar("Loading nodes".to_string(), df_view.num_rows)?;
-
-    let mut node_col_resolved = vec![];
-    let mut node_type_col_resolved = vec![];
-
-    let cache = graph.get_cache();
-    let mut write_locked_graph = graph.write_lock().map_err(into_graph_err)?;
-    let cache_shards = cache.map(|cache| {
-        (0..write_locked_graph.num_shards())
-            .map(|_| cache.fork())
-            .collect::<Vec<_>>()
-    });
-
-    for chunk in df_view.chunks {
-        let df = chunk?;
-        let start_id = graph.reserve_event_ids(df.len()).map_err(into_graph_err)?;
-        let prop_cols =
-            combine_properties_arrow(properties, &properties_indices, &df, |key, dtype| {
-                graph
-                    .resolve_node_property(key, dtype, false)
-                    .map_err(into_graph_err)
-            })?;
-        let metadata_cols =
-            combine_properties_arrow(metadata, &metadata_indices, &df, |key, dtype| {
-                graph
-                    .resolve_node_property(key, dtype, true)
-                    .map_err(into_graph_err)
-            })?;
-        let node_type_col = lift_node_type_col(node_type, node_type_index, &df)?;
-
-        let time_col = df.time_col(time_index)?;
-        let node_col = df.node_col(node_id_index)?;
-
-        node_col_resolved.resize_with(df.len(), Default::default);
-        node_type_col_resolved.resize_with(df.len(), Default::default);
-
-        node_col
-            .par_iter()
-            .zip(node_col_resolved.par_iter_mut())
-            .zip(node_type_col.par_iter())
-            .zip(node_type_col_resolved.par_iter_mut())
-            .try_for_each(|(((gid, resolved), node_type), node_type_resolved)| {
-                let gid = gid.ok_or(LoadError::FatalError)?;
-                let vid = write_locked_graph
-                    .resolve_node(gid)
-                    .map_err(|_| LoadError::FatalError)?;
-                let node_type_res = write_locked_graph.resolve_node_type(node_type).inner();
-                *node_type_resolved = node_type_res;
-                if let Some(cache) = cache {
-                    cache.resolve_node(vid, gid);
-                }
-                *resolved = vid.inner();
-                Ok::<(), LoadError>(())
-            })?;
-
-        let g = write_locked_graph.graph;
-        let update_time = |time| g.update_time(time);
-
-        write_locked_graph
-            .nodes
-            .resize(write_locked_graph.num_nodes());
-
-        write_locked_graph
-            .nodes
-            .par_iter_mut()
-            .try_for_each(|mut shard| {
-                let mut t_props = vec![];
-                let mut c_props = vec![];
-
-                for (idx, (((vid, time), node_type), gid)) in node_col_resolved
-                    .iter()
-                    .zip(time_col.iter())
-                    .zip(node_type_col_resolved.iter())
-                    .zip(node_col.iter())
-                    .enumerate()
-                {
-                    let shard_id = shard.shard_id();
-                    let node_exists = if let Some(mut_node) = shard.get_mut(*vid) {
-                        mut_node.init(*vid, gid);
-                        mut_node.node_type = *node_type;
-                        t_props.clear();
-                        t_props.extend(prop_cols.iter_row(idx));
-
-                        c_props.clear();
-                        c_props.extend(metadata_cols.iter_row(idx));
-                        c_props.extend_from_slice(&shared_metadata);
-
-                        if let Some(caches) = cache_shards.as_ref() {
-                            let cache = &caches[shard_id];
-                            cache.add_node_update(EventTime(time, start_id + idx), *vid, &t_props);
-                            cache.add_node_cprops(*vid, &c_props);
-                        }
-
-                        for (id, prop) in c_props.drain(..) {
-                            mut_node.add_metadata(id, prop)?;
-                        }
-
-                        true
-                    } else {
-                        false
-                    };
-
-                    if node_exists {
-                        let t = EventTime(time, start_id + idx);
-                        update_time(t);
-                        let prop_i = shard.t_prop_log_mut().push(t_props.drain(..))?;
-                        if let Some(mut_node) = shard.get_mut(*vid) {
-                            mut_node.update_t_prop_time(t, prop_i);
-                        }
-                    }
-                }
-                Ok::<_, GraphError>(())
-            })?;
-
-        #[cfg(feature = "python")]
-        let _ = pb.update(df.len());
-    }
-    Ok(())
-}
-
-pub fn load_edges_from_df<
-    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps + InternalCache,
->(
-    df_view: DFView<impl Iterator<Item = Result<DFChunk, GraphError>>>,
-    time: &str,
-    src: &str,
-    dst: &str,
-    properties: &[&str],
-    metadata: &[&str],
-    shared_metadata: Option<&HashMap<String, Prop>>,
-    layer: Option<&str>,
-    layer_col: Option<&str>,
-    graph: &G,
-) -> Result<(), GraphError> {
-    if matches!(df_view.is_empty(), Some(true)) {
-        return Ok(());
-    }
-    let properties_indices = properties
-        .iter()
-        .map(|name| df_view.get_index(name))
-        .collect::<Result<Vec<_>, GraphError>>()?;
-    let metadata_indices = metadata
-        .iter()
-        .map(|name| df_view.get_index(name))
-        .collect::<Result<Vec<_>, GraphError>>()?;
-
-    let src_index = df_view.get_index(src)?;
-    let dst_index = df_view.get_index(dst)?;
-    let time_index = df_view.get_index(time)?;
-    let layer_index = if let Some(layer_col) = layer_col {
-        Some(df_view.get_index(layer_col.as_ref())?)
-    } else {
-        None
-    };
-    let shared_metadata = process_shared_properties(shared_metadata, |key, dtype| {
-        graph
-            .resolve_edge_property(key, dtype, true)
-            .map_err(into_graph_err)
-    })?;
-
-    #[cfg(feature = "python")]
-    let mut pb = build_progress_bar("Loading edges".to_string(), df_view.num_rows)?;
-    #[cfg(feature = "python")]
-    let _ = pb.update(0);
-
-    let mut src_col_resolved = vec![];
-    let mut dst_col_resolved = vec![];
-    let mut eid_col_resolved: Vec<EID> = vec![];
-
-    let cache = graph.get_cache();
-    let mut write_locked_graph = graph.write_lock().map_err(into_graph_err)?;
-    let cache_shards = cache.map(|cache| {
-        (0..write_locked_graph.num_shards())
-            .map(|_| cache.fork())
-            .collect::<Vec<_>>()
-    });
-
-    for chunk in df_view.chunks {
-        let df = chunk?;
-        let start_idx = graph.reserve_event_ids(df.len()).map_err(into_graph_err)?;
-        let prop_cols =
-            combine_properties_arrow(properties, &properties_indices, &df, |key, dtype| {
-                graph
-                    .resolve_edge_property(key, dtype, false)
-                    .map_err(into_graph_err)
-            })?;
-        let metadata_cols =
-            combine_properties_arrow(metadata, &metadata_indices, &df, |key, dtype| {
-                graph
-                    .resolve_edge_property(key, dtype, true)
-                    .map_err(into_graph_err)
-            })?;
-
-        src_col_resolved.resize_with(df.len(), Default::default);
-        dst_col_resolved.resize_with(df.len(), Default::default);
-
-        // let src_col_shared = atomic_usize_from_mut_slice(cast_slice_mut(&mut src_col_resolved));
-        // let dst_col_shared = atomic_usize_from_mut_slice(cast_slice_mut(&mut dst_col_resolved));
-
-        let layer = lift_layer_col(layer, layer_index, &df)?;
-        let layer_col_resolved = layer.resolve(graph)?;
-
-        let src_col = df.node_col(src_index)?;
-        src_col.validate(graph, LoadError::MissingSrcError)?;
-
-        let dst_col = df.node_col(dst_index)?;
-        dst_col.validate(graph, LoadError::MissingDstError)?;
-
-        let time_col = df.time_col(time_index)?;
-
-        // It's our graph, no one else can change it
-        src_col_resolved.resize_with(df.len(), Default::default);
-        src_col
-            .par_iter()
-            .zip(src_col_resolved.par_iter_mut())
-            .try_for_each(|(gid, resolved)| {
-                let gid = gid.ok_or(LoadError::FatalError)?;
-                let vid = write_locked_graph
-                    .resolve_node(gid)
-                    .map_err(|_| LoadError::FatalError)?;
-                if let Some(cache) = cache {
-                    cache.resolve_node(vid, gid);
-                }
-                *resolved = vid.inner();
-                Ok::<(), LoadError>(())
-            })?;
-
-        dst_col_resolved.resize_with(df.len(), Default::default);
-        dst_col
-            .par_iter()
-            .zip(dst_col_resolved.par_iter_mut())
-            .try_for_each(|(gid, resolved)| {
-                let gid = gid.ok_or(LoadError::FatalError)?;
-                let vid = write_locked_graph
-                    .resolve_node(gid)
-                    .map_err(|_| LoadError::FatalError)?;
-                if let Some(cache) = cache {
-                    cache.resolve_node(vid, gid);
-                }
-                *resolved = vid.inner();
-                Ok::<(), LoadError>(())
-            })?;
-
-        write_locked_graph
-            .nodes
-            .resize(write_locked_graph.num_nodes());
-
-        // resolve all the edges
-        eid_col_resolved.resize_with(df.len(), Default::default);
-        let eid_col_shared = atomic_usize_from_mut_slice(cast_slice_mut(&mut eid_col_resolved));
-        let g = write_locked_graph.graph;
-        let next_edge_id = || g.storage.edges.next_id();
-        let update_time = |time| g.update_time(time);
-        write_locked_graph
-            .nodes
-            .par_iter_mut()
-            .for_each(|mut shard| {
-                for (row, ((((src, src_gid), dst), time), layer)) in src_col_resolved
-                    .iter()
-                    .zip(src_col.iter())
-                    .zip(dst_col_resolved.iter())
-                    .zip(time_col.iter())
-                    .zip(layer_col_resolved.iter())
-                    .enumerate()
-                {
-                    let shard_id = shard.shard_id();
-                    if let Some(src_node) = shard.get_mut(*src) {
-                        src_node.init(*src, src_gid);
-                        update_time(EventTime(time, start_idx + row));
-                        let eid = match src_node.find_edge_eid(*dst, &LayerIds::All) {
-                            None => {
-                                let eid = next_edge_id();
-                                if let Some(cache_shards) = cache_shards.as_ref() {
-                                    cache_shards[shard_id].resolve_edge(
-                                        MaybeNew::New(eid),
-                                        *src,
-                                        *dst,
-                                    );
-                                }
-                                eid
-                            }
-                            Some(eid) => eid,
-                        };
-                        src_node
-                            .update_time(EventTime(time, start_idx + row), eid.with_layer(*layer));
-                        src_node.add_edge(*dst, Direction::OUT, *layer, eid);
-                        eid_col_shared[row].store(eid.0, Ordering::Relaxed);
-                    }
-                }
-            });
-
-        // link the destinations
-        write_locked_graph
-            .nodes
-            .par_iter_mut()
-            .for_each(|mut shard| {
-                for (row, ((((src, (dst, dst_gid)), eid), time), layer)) in src_col_resolved
-                    .iter()
-                    .zip(dst_col_resolved.iter().zip(dst_col.iter()))
-                    .zip(eid_col_resolved.iter())
-                    .zip(time_col.iter())
-                    .zip(layer_col_resolved.iter())
-                    .enumerate()
-                {
-                    if let Some(node) = shard.get_mut(*dst) {
-                        node.init(*dst, dst_gid);
-                        node.update_time(EventTime(time, row + start_idx), eid.with_layer(*layer));
-                        node.add_edge(*src, Direction::IN, *layer, *eid)
-                    }
-                }
-            });
-
-        write_locked_graph
-            .edges
-            .par_iter_mut()
-            .try_for_each(|mut shard| {
-                let mut t_props = vec![];
-                let mut c_props = vec![];
-                for (idx, ((((src, dst), time), eid), layer)) in src_col_resolved
-                    .iter()
-                    .zip(dst_col_resolved.iter())
-                    .zip(time_col.iter())
-                    .zip(eid_col_resolved.iter())
-                    .zip(layer_col_resolved.iter())
-                    .enumerate()
-                {
-                    let shard_id = shard.shard_id();
-                    if let Some(mut edge) = shard.get_mut(*eid) {
-                        let edge_store = edge.edge_store_mut();
-                        if !edge_store.initialised() {
-                            edge_store.src = *src;
-                            edge_store.dst = *dst;
-                            edge_store.eid = *eid;
-                        }
-                        let t = EventTime(time, start_idx + idx);
-                        edge.additions_mut(*layer).insert(t);
-                        t_props.clear();
-                        t_props.extend(prop_cols.iter_row(idx));
-
-                        c_props.clear();
-                        c_props.extend(metadata_cols.iter_row(idx));
-                        c_props.extend_from_slice(&shared_metadata);
-
-                        if let Some(caches) = cache_shards.as_ref() {
-                            let cache = &caches[shard_id];
-                            cache.add_edge_update(t, *eid, &t_props, *layer);
-                            cache.add_edge_cprops(*eid, *layer, &c_props);
-                        }
-
-                        if !t_props.is_empty() || !c_props.is_empty() {
-                            let edge_layer = edge.layer_mut(*layer);
-
-                            for (id, prop) in t_props.drain(..) {
-                                edge_layer.add_prop(t, id, prop)?;
-                            }
-
-                            for (id, prop) in c_props.drain(..) {
-                                edge_layer.update_metadata(id, prop)?;
-                            }
-                        }
-                    }
-                }
-                Ok::<(), GraphError>(())
-            })?;
-        if let Some(cache) = cache {
-            cache.write()?;
-        }
-        if let Some(cache_shards) = cache_shards.as_ref() {
-            for cache in cache_shards {
-                cache.write()?;
-            }
-        }
-
-        #[cfg(feature = "python")]
-        let _ = pb.update(df.len());
-    }
-    Ok(())
-}
-
-pub(crate) fn load_edge_deletions_from_df<
-    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps + DeletionOps,
->(
-    df_view: DFView<impl Iterator<Item = Result<DFChunk, GraphError>>>,
-    time: &str,
-    src: &str,
-    dst: &str,
-    layer: Option<&str>,
-    layer_col: Option<&str>,
-    graph: &G,
-) -> Result<(), GraphError> {
-    if matches!(df_view.is_empty(), Some(true)) {
-        return Ok(());
-    }
-    let src_index = df_view.get_index(src)?;
-    let dst_index = df_view.get_index(dst)?;
-    let time_index = df_view.get_index(time)?;
-    let layer_index = layer_col.map(|layer_col| df_view.get_index(layer_col.as_ref()));
-    let layer_index = layer_index.transpose()?;
-    #[cfg(feature = "python")]
-    let mut pb = build_progress_bar("Loading edge deletions".to_string(), df_view.num_rows)?;
-
-    for chunk in df_view.chunks {
-        let df = chunk?;
-        let start_idx = graph.reserve_event_ids(df.len()).map_err(into_graph_err)?;
-        let layer = lift_layer_col(layer, layer_index, &df)?;
-        let src_col = df.node_col(src_index)?;
-        let dst_col = df.node_col(dst_index)?;
-        let time_col = df.time_col(time_index)?;
-        src_col
-            .par_iter()
-            .zip(dst_col.par_iter())
-            .zip(time_col.par_iter())
-            .zip(layer.par_iter())
-            .enumerate()
-            .try_for_each(|(idx, (((src, dst), time), layer))| {
-                let src = src.ok_or(LoadError::MissingSrcError)?;
-                let dst = dst.ok_or(LoadError::MissingDstError)?;
-                graph.delete_edge((time, start_idx + idx), src, dst, layer)?;
-                Ok::<(), GraphError>(())
-            })?;
-        #[cfg(feature = "python")]
-        let _ = pb.update(df.len());
-    }
-
-    Ok(())
-}
-
-pub(crate) fn load_node_props_from_df<
-    'a,
-    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps + InternalCache,
->(
-    df_view: DFView<impl Iterator<Item = Result<DFChunk, GraphError>>>,
-    node_id: &str,
-    node_type: Option<&str>,
-    node_type_col: Option<&str>,
-    metadata: &[&str],
-    shared_metadata: Option<&HashMap<String, Prop>>,
-    graph: &G,
-) -> Result<(), GraphError> {
-    if matches!(df_view.is_empty(), Some(true)) {
-        return Ok(());
-    }
-    let metadata_indices = metadata
-        .iter()
-        .map(|name| df_view.get_index(name))
-        .collect::<Result<Vec<_>, GraphError>>()?;
-
-    let node_type_index =
-        node_type_col.map(|node_type_col| df_view.get_index(node_type_col.as_ref()));
-    let node_type_index = node_type_index.transpose()?;
-
-    let node_id_index = df_view.get_index(node_id)?;
-
-    let shared_metadata = process_shared_properties(shared_metadata, |key, dtype| {
-        graph
-            .resolve_node_property(key, dtype, true)
-            .map_err(into_graph_err)
-    })?;
-
-    #[cfg(feature = "python")]
-    let mut pb = build_progress_bar("Loading node properties".to_string(), df_view.num_rows)?;
-
-    let mut node_col_resolved = vec![];
-    let mut node_type_col_resolved = vec![];
-
-    let cache = graph.get_cache();
-    let mut write_locked_graph = graph.write_lock().map_err(into_graph_err)?;
-    let cache_shards = cache.map(|cache| {
-        (0..write_locked_graph.num_shards())
-            .map(|_| cache.fork())
-            .collect::<Vec<_>>()
-    });
-
-    for chunk in df_view.chunks {
-        let df = chunk?;
-        let metadata_cols =
-            combine_properties_arrow(metadata, &metadata_indices, &df, |key, dtype| {
-                graph
-                    .resolve_node_property(key, dtype, true)
-                    .map_err(into_graph_err)
-            })?;
-        let node_type_col = lift_node_type_col(node_type, node_type_index, &df)?;
-        let node_col = df.node_col(node_id_index)?;
-
-        node_col_resolved.resize_with(df.len(), Default::default);
-        node_type_col_resolved.resize_with(df.len(), Default::default);
-
-        node_col
-            .par_iter()
-            .zip(node_col_resolved.par_iter_mut())
-            .zip(node_type_col.par_iter())
-            .zip(node_type_col_resolved.par_iter_mut())
-            .try_for_each(|(((gid, resolved), node_type), node_type_resolved)| {
-                let gid = gid.ok_or(LoadError::FatalError)?;
-                let vid = write_locked_graph
-                    .resolve_node(gid)
-                    .map_err(|_| LoadError::FatalError)?;
-                let node_type_res = write_locked_graph.resolve_node_type(node_type).inner();
-                *node_type_resolved = node_type_res;
-                if let Some(cache) = cache {
-                    cache.resolve_node(vid, gid);
-                }
-                *resolved = vid.inner();
-                Ok::<(), LoadError>(())
-            })?;
-
-        write_locked_graph
-            .nodes
-            .resize(write_locked_graph.num_nodes());
-
-        write_locked_graph
-            .nodes
-            .par_iter_mut()
-            .try_for_each(|mut shard| {
-                let mut c_props = vec![];
-
-                for (idx, ((vid, node_type), gid)) in node_col_resolved
-                    .iter()
-                    .zip(node_type_col_resolved.iter())
-                    .zip(node_col.iter())
-                    .enumerate()
-                {
-                    let shard_id = shard.shard_id();
-                    if let Some(mut_node) = shard.get_mut(*vid) {
-                        mut_node.init(*vid, gid);
-                        mut_node.node_type = *node_type;
-
-                        c_props.clear();
-                        c_props.extend(metadata_cols.iter_row(idx));
-                        c_props.extend_from_slice(&shared_metadata);
-
-                        if let Some(caches) = cache_shards.as_ref() {
-                            let cache = &caches[shard_id];
-                            cache.add_node_cprops(*vid, &c_props);
-                        }
-
-                        for (id, prop) in c_props.drain(..) {
-                            mut_node.add_metadata(id, prop)?;
-                        }
-                    };
-                }
-                Ok::<_, GraphError>(())
-            })?;
-
-        #[cfg(feature = "python")]
-        let _ = pb.update(df.len());
-    }
-    Ok(())
-}
-
-pub(crate) fn load_edges_props_from_df<
-    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps + InternalCache,
->(
-    df_view: DFView<impl Iterator<Item = Result<DFChunk, GraphError>>>,
-    src: &str,
-    dst: &str,
-    metadata: &[&str],
-    shared_metadata: Option<&HashMap<String, Prop>>,
-    layer: Option<&str>,
-    layer_col: Option<&str>,
-    graph: &G,
-) -> Result<(), GraphError> {
-    if matches!(df_view.is_empty(), Some(true)) {
-        return Ok(());
-    }
-    let metadata_indices = metadata
-        .iter()
-        .map(|name| df_view.get_index(name))
-        .collect::<Result<Vec<_>, GraphError>>()?;
-
-    let src_index = df_view.get_index(src)?;
-    let dst_index = df_view.get_index(dst)?;
-    let layer_index = if let Some(layer_col) = layer_col {
-        Some(df_view.get_index(layer_col.as_ref())?)
-    } else {
-        None
-    };
-    let shared_metadata = process_shared_properties(shared_metadata, |key, dtype| {
-        graph
-            .resolve_edge_property(key, dtype, true)
-            .map_err(into_graph_err)
-    })?;
-
-    #[cfg(feature = "python")]
-    let mut pb = build_progress_bar("Loading edge properties".to_string(), df_view.num_rows)?;
-    #[cfg(feature = "python")]
-    let _ = pb.update(0);
-
-    let mut src_col_resolved = vec![];
-    let mut dst_col_resolved = vec![];
-    let mut eid_col_resolved = vec![];
-
-    let cache = graph.get_cache();
-    let mut write_locked_graph = graph.write_lock().map_err(into_graph_err)?;
-    let cache_shards = cache.map(|cache| {
-        (0..write_locked_graph.num_shards())
-            .map(|_| cache.fork())
-            .collect::<Vec<_>>()
-    });
-
-    let g = write_locked_graph.graph;
-
-    for chunk in df_view.chunks {
-        let df = chunk?;
-        let metadata_cols =
-            combine_properties_arrow(metadata, &metadata_indices, &df, |key, dtype| {
-                graph
-                    .resolve_edge_property(key, dtype, true)
-                    .map_err(into_graph_err)
-            })?;
-        let layer = lift_layer_col(layer, layer_index, &df)?;
-        let layer_col_resolved = layer.resolve(graph)?;
-
-        let src_col = df.node_col(src_index)?;
-        src_col.validate(graph, LoadError::MissingSrcError)?;
-
-        let dst_col = df.node_col(dst_index)?;
-        dst_col.validate(graph, LoadError::MissingDstError)?;
-
-        // It's our graph, no one else can change it
-        src_col_resolved.resize_with(df.len(), Default::default);
-        src_col
-            .par_iter()
-            .zip(src_col_resolved.par_iter_mut())
-            .try_for_each(|(gid, resolved)| {
-                let gid = gid.ok_or(LoadError::FatalError)?;
-                let vid = g
-                    .resolve_node_ref(gid.as_node_ref())
-                    .ok_or(LoadError::MissingNodeError)?;
-                *resolved = vid;
-                Ok::<(), LoadError>(())
-            })?;
-
-        dst_col_resolved.resize_with(df.len(), Default::default);
-        dst_col
-            .par_iter()
-            .zip(dst_col_resolved.par_iter_mut())
-            .try_for_each(|(gid, resolved)| {
-                let gid = gid.ok_or(LoadError::FatalError)?;
-                let vid = g
-                    .resolve_node_ref(gid.as_node_ref())
-                    .ok_or(LoadError::MissingNodeError)?;
-                *resolved = vid;
-                Ok::<(), LoadError>(())
-            })?;
-
-        // resolve all the edges
-        eid_col_resolved.resize_with(df.len(), Default::default);
-        let eid_col_shared = atomic_usize_from_mut_slice(cast_slice_mut(&mut eid_col_resolved));
-        write_locked_graph
-            .nodes
-            .par_iter_mut()
-            .try_for_each(|shard| {
-                for (row, (src, dst)) in src_col_resolved
-                    .iter()
-                    .zip(dst_col_resolved.iter())
-                    .enumerate()
-                {
-                    if let Some(src_node) = shard.get(*src) {
-                        // we know this is here
-                        let EID(eid) = src_node
-                            .find_edge_eid(*dst, &LayerIds::All)
-                            .ok_or(LoadError::MissingEdgeError(*src, *dst))?;
-                        eid_col_shared[row].store(eid, Ordering::Relaxed);
-                    }
-                }
-                Ok::<_, LoadError>(())
-            })?;
-
-        write_locked_graph
-            .edges
-            .par_iter_mut()
-            .try_for_each(|mut shard| {
-                let mut c_props = vec![];
-                for (idx, (eid, layer)) in eid_col_resolved
-                    .iter()
-                    .zip(layer_col_resolved.iter())
-                    .enumerate()
-                {
-                    let shard_id = shard.shard_id();
-                    if let Some(mut edge) = shard.get_mut(*eid) {
-                        c_props.clear();
-                        c_props.extend(metadata_cols.iter_row(idx));
-                        c_props.extend_from_slice(&shared_metadata);
-
-                        if let Some(caches) = cache_shards.as_ref() {
-                            let cache = &caches[shard_id];
-                            cache.add_edge_cprops(*eid, *layer, &c_props);
-                        }
-
-                        if !c_props.is_empty() {
-                            let edge_layer = edge.layer_mut(*layer);
-
-                            for (id, prop) in c_props.drain(..) {
-                                edge_layer.update_metadata(id, prop)?;
-                            }
-                        }
-                    }
-                }
-                Ok::<(), GraphError>(())
-            })?;
-
-        if let Some(cache) = cache {
-            cache.write()?;
-        }
-        if let Some(cache_shards) = cache_shards.as_ref() {
-            for cache in cache_shards {
-                cache.write()?;
-            }
-        }
-
-        #[cfg(feature = "python")]
-        let _ = pb.update(df.len());
-    }
-    Ok(())
-}
-
-pub(crate) fn load_graph_props_from_df<
-    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps,
->(
-    df_view: DFView<impl Iterator<Item = Result<DFChunk, GraphError>>>,
-    time: &str,
-    properties: Option<&[&str]>,
-    metadata: Option<&[&str]>,
-    graph: &G,
-) -> Result<(), GraphError> {
-    if matches!(df_view.is_empty(), Some(true)) {
-        return Ok(());
-    }
-    let properties = properties.unwrap_or(&[]);
-    let metadata = metadata.unwrap_or(&[]);
-
-    let properties_indices = properties
-        .iter()
-        .map(|name| df_view.get_index(name))
-        .collect::<Result<Vec<_>, GraphError>>()?;
-    let metadata_indices = metadata
-        .iter()
-        .map(|name| df_view.get_index(name))
-        .collect::<Result<Vec<_>, GraphError>>()?;
-
-    let time_index = df_view.get_index(time)?;
-
-    #[cfg(feature = "python")]
-    let mut pb = build_progress_bar("Loading graph properties".to_string(), df_view.num_rows)?;
-
-    for chunk in df_view.chunks {
-        let df = chunk?;
-        let start_id = graph.reserve_event_ids(df.len()).map_err(into_graph_err)?;
-        let prop_cols =
-            combine_properties_arrow(properties, &properties_indices, &df, |key, dtype| {
-                graph
-                    .resolve_graph_property(key, dtype, false)
-                    .map_err(into_graph_err)
-            })?;
-        let metadata_cols =
-            combine_properties_arrow(metadata, &metadata_indices, &df, |key, dtype| {
-                graph
-                    .resolve_graph_property(key, dtype, true)
-                    .map_err(into_graph_err)
-            })?;
-        let time_col = df.time_col(time_index)?;
-
-        time_col
-            .par_iter()
-            .zip(prop_cols.par_rows())
-            .zip(metadata_cols.par_rows())
-            .enumerate()
-            .try_for_each(|(id, ((time, t_props), c_props))| {
-                let t = EventTime(time, start_id + id);
-                let t_props: Vec<_> = t_props.collect();
-                if !t_props.is_empty() {
-                    graph
-                        .internal_add_properties(t, &t_props)
-                        .map_err(into_graph_err)?;
-                }
-
-                let c_props: Vec<_> = c_props.collect();
-
-                if !c_props.is_empty() {
-                    graph
-                        .internal_add_metadata(&c_props)
-                        .map_err(into_graph_err)?;
-                }
-                Ok::<(), GraphError>(())
-            })?;
-        #[cfg(feature = "python")]
-        let _ = pb.update(df.len());
-    }
-    Ok(())
-}
diff --git a/raphtory/src/io/arrow/df_loaders/edge_props.rs b/raphtory/src/io/arrow/df_loaders/edge_props.rs
new file mode 100644
index 0000000000..6f391238a0
--- /dev/null
+++ b/raphtory/src/io/arrow/df_loaders/edge_props.rs
@@ -0,0 +1,260 @@
+#[cfg(feature = "progress")]
+use crate::io::arrow::df_loaders::build_progress_bar;
+
+use crate::{
+    db::api::view::StaticGraphViewOps,
+    errors::{into_graph_err, GraphError, LoadError},
+    io::arrow::{
+        dataframe::{DFChunk, DFView},
+        df_loaders::{
+            edges::{get_or_resolve_node_vids, store_node_ids, ColumnNames},
+            process_shared_properties,
+        },
+        layer_col::lift_layer_col,
+        prop_handler::*,
+    },
+    prelude::*,
+};
+use arrow::{array::AsArray, datatypes::UInt64Type};
+use bytemuck::checked::cast_slice_mut;
+use db4_graph::WriteLockedGraph;
+use itertools::izip;
+use kdam::BarExt;
+use raphtory_api::{
+    atomic_extra::atomic_usize_from_mut_slice,
+    core::entities::{properties::prop::AsPropRef, LayerId, EID},
+};
+use raphtory_core::entities::VID;
+use raphtory_storage::mutation::addition_ops::SessionAdditionOps;
+use rayon::prelude::*;
+use std::{
+    collections::HashMap,
+    sync::{
+        atomic::{AtomicUsize, Ordering},
+        mpsc,
+    },
+};
+use storage::{
+    api::{edges::EdgeSegmentOps, nodes::NodeSegmentOps},
+    pages::locked::{edges::LockedEdgePage, nodes::LockedNodePage},
+    Extension,
+};
+
+#[allow(clippy::too_many_arguments)]
+pub fn load_edges_from_df<G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps>(
+    df_view: DFView<impl IntoIterator<Item = Result<DFChunk, GraphError>>>,
+    column_names: ColumnNames,
+    resolve_nodes: bool,
+    metadata: &[&str],
+    shared_metadata: Option<&HashMap<String, Prop>>,
+    layer: Option<&str>,
+    graph: &G,
+) -> Result<(), GraphError> {
+    if df_view.is_empty() {
+        return Ok(());
+    }
+
+    let ColumnNames {
+        src,
+        dst,
+        layer_col,
+        layer_id_col,
+        ..
+    } = column_names;
+
+    let metadata_indices = metadata
+        .iter()
+        .map(|name| df_view.get_index(name))
+        .collect::<Result<Vec<_>, GraphError>>()?;
+
+    let src_index = df_view.get_index(src)?;
+    let dst_index = df_view.get_index(dst)?;
+    let layer_id_index = layer_id_col.and_then(|name| df_view.get_index_opt(name));
+    let layer_index = layer_col.map(|name| df_view.get_index(name)).transpose()?;
+
+    let session = graph.write_session().map_err(into_graph_err)?;
+    let shared_metadata = process_shared_properties(shared_metadata, |key, dtype| {
+        session
+            .resolve_edge_property(key, dtype, true)
+            .map_err(into_graph_err)
+    })?;
+
+    #[cfg(feature = "progress")]
+    let mut pb = build_progress_bar("Loading edges metadata".to_string(), df_view.num_rows)?;
+
+    let mut src_col_resolved: Vec<VID> = vec![];
+    let mut dst_col_resolved: Vec<VID> = vec![];
+    let mut eid_col_resolved: Vec<EID> = vec![];
+
+    for chunk in df_view.chunks {
+        let df = chunk?;
+        let metadata_cols =
+            combine_properties_arrow(metadata, &metadata_indices, &df, |key, dtype| {
+                session
+                    .resolve_edge_property(key, dtype, true)
+                    .map_err(into_graph_err)
+            })?;
+        // validate src and dst columns
+        let src_col = df.node_col(src_index)?;
+        let dst_col = df.node_col(dst_index)?;
+        if resolve_nodes {
+            src_col.validate(graph, LoadError::MissingSrcError)?;
+            dst_col.validate(graph, LoadError::MissingDstError)?;
+        }
+        let layer = lift_layer_col(layer, layer_index, &df)?;
+        let layer_id_values = layer_id_index
+            .map(|idx| {
+                df.chunk[idx]
+                    .as_primitive_opt::<UInt64Type>()
+                    .ok_or_else(|| LoadError::InvalidLayerType(df.chunk[idx].data_type().clone()))
+                    .map(|array| array.values().as_ref())
+            })
+            .transpose()?;
+        let layer_col_resolved = layer.resolve_layer(layer_id_values, graph)?;
+
+        let (src_vids, dst_vids, gid_str_cache) = get_or_resolve_node_vids(
+            graph,
+            src_index,
+            dst_index,
+            &mut src_col_resolved,
+            &mut dst_col_resolved,
+            resolve_nodes,
+            &df,
+            &src_col,
+            &dst_col,
+        )?;
+
+        let mut write_locked_graph = graph.write_lock().map_err(into_graph_err)?;
+
+        eid_col_resolved.resize_with(df.len(), Default::default);
+        let eid_col_shared = atomic_usize_from_mut_slice(cast_slice_mut(&mut eid_col_resolved));
+
+        let WriteLockedGraph { nodes, .. } = &mut write_locked_graph;
+
+        // Generate all edge_ids + add outbound edges
+        nodes.par_iter_mut().try_for_each(|locked_page| {
+            // Zip all columns for iteration.
+            let zip = izip!(src_vids.iter(), dst_vids.iter());
+            add_and_resolve_outbound_edges(&eid_col_shared, locked_page, zip)?;
+            // resolve_nodes=false
+            // assumes we are loading our own graph, via the parquet loaders,
+            // so previous calls have already stored the node ids and types
+            if resolve_nodes {
+                store_node_ids(&gid_str_cache, locked_page);
+            }
+            Ok::<_, GraphError>(())
+        })?;
+
+        drop(write_locked_graph);
+
+        let mut write_locked_graph = graph.write_lock().map_err(into_graph_err)?;
+
+        write_locked_graph.edges.par_iter_mut().for_each(|shard| {
+            let zip = izip!(
+                src_vids.iter(),
+                dst_vids.iter(),
+                eid_col_resolved.iter(),
+                layer_col_resolved.iter(),
+            );
+            update_edge_metadata(&shared_metadata, &metadata_cols, shard, zip);
+        });
+
+        #[cfg(feature = "progress")]
+        let _ = pb.update(df.len());
+    }
+    Ok::<_, GraphError>(())
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn load_edges_from_df_prefetch<G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps>(
+    df_view: DFView<impl Iterator<Item = Result<DFChunk, GraphError>> + Send>,
+    column_names: ColumnNames,
+    resolve_nodes: bool,
+    metadata: &[&str],
+    shared_metadata: Option<&HashMap<String, Prop>>,
+    layer: Option<&str>,
+    graph: &G,
+) -> Result<(), GraphError> {
+    let DFView {
+        names,
+        chunks,
+        num_rows,
+    } = df_view;
+    rayon::scope(|s| {
+        let (tx, rx) = mpsc::sync_channel(2);
+
+        s.spawn(move |_| {
+            let sender = tx;
+            for chunk in chunks {
+                if let Err(e) = sender.send(chunk) {
+                    eprintln!("Error pre-fetching chunk for loading edges, possibly receiver has been dropped {e}");
+                    break;
+                }
+            }
+        });
+
+        let df_view_prefetch = DFView {
+            names,
+            chunks: rx,
+            num_rows,
+        };
+
+        load_edges_from_df(
+            df_view_prefetch,
+            column_names,
+            resolve_nodes,
+            metadata,
+            shared_metadata,
+            layer,
+            graph,
+        )?;
+        Ok::<(), GraphError>(())
+    })?;
+
+    Ok(())
+}
+
+#[inline(never)]
+fn add_and_resolve_outbound_edges<'a, NS: NodeSegmentOps<Extension = Extension>>(
+    eid_col_shared: &&mut [AtomicUsize],
+    locked_page: &mut LockedNodePage<'_, NS>,
+    zip: impl Iterator<Item = (&'a VID, &'a VID)>,
+) -> Result<(), LoadError> {
+    let writer = locked_page.writer();
+    for (row, (src, dst)) in zip.enumerate() {
+        if let Some(src_pos) = writer.resolve_pos(*src) {
+            // find the original EID in the static graph if it exists
+            // otherwise create a new one
+            if let Some(edge_id) = writer.get_out_edge(src_pos, *dst, LayerId(0)) {
+                eid_col_shared[row].store(edge_id.0, Ordering::Relaxed);
+            } else {
+                return Err(LoadError::MissingEdgeError(*src, *dst));
+            };
+        }
+    }
+    Ok(())
+}
+
+#[inline(never)]
+fn update_edge_metadata<'a, ES: EdgeSegmentOps<Extension = Extension>>(
+    shared_metadata: &[(usize, Prop)],
+    metadata_cols: &PropCols,
+    shard: &mut LockedEdgePage<'_, ES>,
+    zip: impl Iterator<Item = (&'a VID, &'a VID, &'a EID, &'a usize)>,
+) {
+    let mut c_props = Vec::new();
+    let mut writer = shard.writer();
+    for (row, (src, dst, eid, layer)) in zip.enumerate() {
+        if let Some(eid_pos) = writer.resolve_pos(*eid) {
+            c_props.clear();
+            c_props.extend(metadata_cols.iter_row(row));
+            c_props.extend(
+                shared_metadata
+                    .iter()
+                    .map(|(id, prop)| (*id, prop.as_prop_ref())),
+            );
+
+            writer.update_c_props(eid_pos, *src, *dst, LayerId(*layer), c_props.drain(..));
+        }
+    }
+}
diff --git a/raphtory/src/io/arrow/df_loaders/edges.rs b/raphtory/src/io/arrow/df_loaders/edges.rs
new file mode 100644
index 0000000000..8edec1fb6f
--- /dev/null
+++ b/raphtory/src/io/arrow/df_loaders/edges.rs
@@ -0,0 +1,702 @@
+#[cfg(feature = "progress")]
+use crate::io::arrow::df_loaders::build_progress_bar;
+
+use crate::{
+    db::api::{storage::storage::PersistenceStrategy, view::StaticGraphViewOps},
+    errors::{into_graph_err, GraphError, LoadError},
+    io::{
+        arrow::{
+            dataframe::{DFChunk, DFView},
+            df_loaders::{
+                extract_secondary_index_col, process_shared_properties, resolve_nodes_with_cache,
+            },
+            layer_col::lift_layer_col,
+            node_col::NodeCol,
+            prop_handler::*,
+        },
+        LOAD_POOL,
+    },
+    prelude::*,
+};
+use arrow::{array::AsArray, datatypes::UInt64Type};
+use bytemuck::checked::cast_slice_mut;
+use db4_graph::WriteLockedGraph;
+use itertools::izip;
+use kdam::BarExt;
+use raphtory_api::{
+    atomic_extra::{atomic_usize_from_mut_slice, atomic_vid_from_mut_slice},
+    core::{
+        entities::{
+            properties::{meta::STATIC_GRAPH_LAYER_ID, prop::AsPropRef},
+            LayerId, EID,
+        },
+        storage::{dict_mapper::MaybeNew, timeindex::EventTime},
+    },
+};
+use raphtory_core::entities::{GidRef, VID};
+use raphtory_storage::mutation::addition_ops::SessionAdditionOps;
+use rayon::prelude::*;
+use std::{
+    collections::HashMap,
+    sync::{
+        atomic::{AtomicBool, AtomicUsize, Ordering},
+        mpsc,
+    },
+};
+use storage::{
+    api::{edges::EdgeSegmentOps, nodes::NodeSegmentOps},
+    pages::{
+        locked::{
+            edges::{LockedEdgePage, WriteLockedEdgePages},
+            nodes::LockedNodePage,
+        },
+        resolve_pos,
+    },
+    Extension,
+};
+
+#[derive(Debug, Copy, Clone)]
+pub struct ColumnNames<'a> {
+    pub time: &'a str,
+    pub secondary_index: Option<&'a str>,
+    pub src: &'a str,
+    pub dst: &'a str,
+    pub edge_id: Option<&'a str>,
+    pub layer_col: Option<&'a str>,
+    pub layer_id_col: Option<&'a str>,
+}
+
+impl<'a> ColumnNames<'a> {
+    pub fn new(
+        time: &'a str,
+        secondary_index: Option<&'a str>,
+
+        src: &'a str,
+        dst: &'a str,
+
+        layer_col: Option<&'a str>,
+    ) -> Self {
+        Self {
+            time,
+            secondary_index,
+            src,
+            dst,
+            layer_col,
+            edge_id: None,
+            layer_id_col: None,
+        }
+    }
+
+    pub fn with_layer_id_col(mut self, layer_id_col: &'a str) -> Self {
+        self.layer_id_col = Some(layer_id_col);
+        self
+    }
+
+    pub fn with_edge_id_col(mut self, edge_id: &'a str) -> Self {
+        self.edge_id = Some(edge_id);
+        self
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn load_edges_from_df_prefetch<
+    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps,
+    I1: Iterator<Item = Result<DFChunk, GraphError>> + Send,
+>(
+    df_view: DFView<I1>,
+    column_names: ColumnNames,
+    resolve_nodes: bool, // this is reserved for internal parquet encoders, this cannot be exposed to users
+    properties: &[&str],
+    metadata: &[&str],
+    shared_metadata: Option<&HashMap<String, Prop>>,
+    layer: Option<&str>,
+    graph: &G,
+    delete: bool, // whether to update edge deletions or additions
+) -> Result<(), GraphError> {
+    let DFView {
+        names,
+        chunks,
+        num_rows,
+    } = df_view;
+
+    LOAD_POOL.install(|| {
+        rayon::scope(|s| {
+            let (tx, rx) = mpsc::sync_channel(2);
+
+            s.spawn(move |_| {
+                let sender = tx;
+                for chunk in chunks {
+                    if let Err(e) = sender.send(chunk) {
+                        eprintln!("Error sending chunk to loader: {}", e);
+                        break;
+                    }
+                }
+            });
+
+            let df_view_prefetch = DFView {
+                names,
+                chunks: rx,
+                num_rows,
+            };
+
+            load_edges_from_df(
+                df_view_prefetch,
+                column_names,
+                resolve_nodes,
+                properties,
+                metadata,
+                shared_metadata,
+                layer,
+                graph,
+                delete,
+            )?;
+            Ok::<(), GraphError>(())
+        })?;
+
+        Ok(())
+    })
+}
+
+pub fn load_edges_from_df<G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps>(
+    df_view: DFView<impl IntoIterator<Item = Result<DFChunk, GraphError>>>,
+    column_names: ColumnNames,
+    resolve_nodes: bool, // this is reserved for internal parquet encoders, this cannot be exposed to users
+    properties: &[&str],
+    metadata: &[&str],
+    shared_metadata: Option<&HashMap<String, Prop>>,
+    layer: Option<&str>,
+    graph: &G,
+    delete: bool, // whether to update edge deletions or additions
+) -> Result<(), GraphError> {
+    if df_view.is_empty() {
+        return Ok(());
+    }
+
+    let ColumnNames {
+        time,
+        secondary_index,
+        src,
+        dst,
+        edge_id,
+        layer_col,
+        layer_id_col,
+    } = column_names;
+
+    let properties_indices = properties
+        .iter()
+        .map(|name| df_view.get_index(name))
+        .collect::<Result<Vec<_>, GraphError>>()?;
+    let metadata_indices = metadata
+        .iter()
+        .map(|name| df_view.get_index(name))
+        .collect::<Result<Vec<_>, GraphError>>()?;
+
+    let src_index = df_view.get_index(src)?;
+    let dst_index = df_view.get_index(dst)?;
+    let time_index = df_view.get_index(time)?;
+    let edge_index = edge_id.and_then(|name| df_view.get_index_opt(name));
+    let layer_id_index = layer_id_col.and_then(|name| df_view.get_index_opt(name));
+    let secondary_index_index = secondary_index
+        .map(|col| df_view.get_index(col))
+        .transpose()?;
+    let layer_index = layer_col.map(|name| df_view.get_index(name)).transpose()?;
+
+    let session = graph.write_session().map_err(into_graph_err)?;
+    let shared_metadata = process_shared_properties(shared_metadata, |key, dtype| {
+        session
+            .resolve_edge_property(key, dtype, true)
+            .map_err(into_graph_err)
+    })?;
+
+    assert!(
+        (resolve_nodes ^ edge_index.is_some()),
+        "resolve_nodes must be false when edge_id is provided or true when edge_id is None, {{resolve_nodes:{resolve_nodes:?}, edge_id:{edge_index:?}}}"
+    );
+
+    assert!(
+        (resolve_nodes ^ layer_id_index.is_some()),
+        "resolve_nodes must be false when layer_id is provided or true when layer_id is None, {{resolve_nodes:{resolve_nodes:?}, layer_id:{layer_id_index:?}}}"
+    );
+
+    #[cfg(feature = "progress")]
+    let mut pb = build_progress_bar("Loading edges".to_string(), df_view.num_rows)?;
+
+    let mut src_col_resolved: Vec<VID> = vec![];
+    let mut dst_col_resolved: Vec<VID> = vec![];
+    let mut eid_col_resolved: Vec<EID> = vec![];
+    let mut eids_exist: Vec<AtomicBool> = vec![]; // exists or needs to be created
+    let mut layer_eids_exist: Vec<AtomicBool> = vec![]; // exists or needs to be created
+
+    // I want to find out which of the segments are touched by every chunk
+    let mut edge_segments_touched = (0..graph.core_graph().num_edge_segments())
+        .map(|_| AtomicBool::new(false))
+        .collect::<Vec<_>>();
+
+    let mut node_segments_touched = (0..graph.core_graph().num_node_segments())
+        .map(|_| AtomicBool::new(false))
+        .collect::<Vec<_>>();
+
+    for chunk in df_view.chunks.into_iter() {
+        let df = chunk?;
+        let prop_cols =
+            combine_properties_arrow(properties, &properties_indices, &df, |key, dtype| {
+                session
+                    .resolve_edge_property(key, dtype, false)
+                    .map_err(into_graph_err)
+            })?;
+        let metadata_cols =
+            combine_properties_arrow(metadata, &metadata_indices, &df, |key, dtype| {
+                session
+                    .resolve_edge_property(key, dtype, true)
+                    .map_err(into_graph_err)
+            })?;
+        // validate src and dst columns
+        let src_col = df.node_col(src_index)?;
+        let dst_col = df.node_col(dst_index)?;
+        if resolve_nodes {
+            src_col.validate(graph, LoadError::MissingSrcError)?;
+            dst_col.validate(graph, LoadError::MissingDstError)?;
+        }
+        let layer = lift_layer_col(layer, layer_index, &df)?;
+        let layer_id_values = layer_id_index
+            .map(|idx| {
+                df.chunk[idx]
+                    .as_primitive_opt::<UInt64Type>()
+                    .ok_or_else(|| LoadError::InvalidLayerType(df.chunk[idx].data_type().clone()))
+                    .map(|array| array.values().as_ref())
+            })
+            .transpose()?;
+        let layer_col_resolved = layer.resolve_layer(layer_id_values, graph)?;
+
+        let (src_vids, dst_vids, gid_str_cache) = get_or_resolve_node_vids(
+            graph,
+            src_index,
+            dst_index,
+            &mut src_col_resolved,
+            &mut dst_col_resolved,
+            resolve_nodes,
+            &df,
+            &src_col,
+            &dst_col,
+        )?;
+
+        let time_col = df.time_col(time_index)?;
+
+        // Load the secondary index column if it exists, otherwise generate from start_id.
+        let secondary_index_col =
+            extract_secondary_index_col::<G>(secondary_index_index, &session, &df)?;
+
+        let mut write_locked_graph = graph.write_lock().map_err(into_graph_err)?;
+        let max_node_segment_len = write_locked_graph
+            .graph()
+            .storage()
+            .nodes()
+            .max_segment_len() as usize;
+
+        node_segments_touched.resize_with(write_locked_graph.nodes.len(), || AtomicBool::new(true));
+
+        if !gid_str_cache.is_empty() {
+            for (_, vid) in &gid_str_cache {
+                let (node_segment, _) = resolve_pos(vid.index(), max_node_segment_len as u32);
+                node_segments_touched[node_segment].store(true, Ordering::Relaxed);
+            }
+        } else {
+            // loading from our own parquet files here
+            let mut last_segment = usize::MAX;
+            for vid in src_vids.iter().chain(dst_vids) {
+                let (segment, _) = resolve_pos(vid.0, max_node_segment_len as u32);
+                if segment != last_segment {
+                    node_segments_touched[segment].store(true, Ordering::Relaxed);
+                }
+                last_segment = segment;
+            }
+        }
+
+        eid_col_resolved.resize_with(df.len(), Default::default);
+        eids_exist.resize_with(df.len(), Default::default);
+        layer_eids_exist.resize_with(df.len(), Default::default);
+        let eid_col_shared = atomic_usize_from_mut_slice(cast_slice_mut(&mut eid_col_resolved));
+
+        let arc_edges = write_locked_graph.graph().storage().edges().clone();
+
+        let next_edge_id = |row: usize| {
+            let (page, pos) = arc_edges.reserve_free_pos(row);
+            pos.as_eid(page, arc_edges.max_page_len())
+        };
+
+        let max_edge_page_len = arc_edges.max_page_len();
+        let WriteLockedGraph {
+            nodes, ref edges, ..
+        } = &mut write_locked_graph;
+
+        let eids = edge_index.and_then(|edge_id_col| {
+            Some(
+                df.chunk[edge_id_col]
+                    .as_primitive_opt::<UInt64Type>()?
+                    .values()
+                    .as_ref(),
+            )
+        });
+
+        // Generate all edge_ids + add outbound edges
+        nodes
+            .par_iter_mut()
+            .enumerate()
+            .for_each(|(segment_id, locked_page)| {
+                if !node_segments_touched[segment_id].load(Ordering::Relaxed) {
+                    // we still need the writer in case we need to flush
+                    if locked_page.segment().is_dirty() {
+                        let mut _writer = locked_page.writer();
+                    }
+                    return;
+                }
+
+                // Zip all columns for iteration.
+                let zip = izip!(
+                    src_vids.iter(),
+                    dst_vids.iter(),
+                    time_col.iter(),
+                    secondary_index_col.iter(),
+                    layer_col_resolved.iter()
+                );
+
+                // resolve_nodes=false
+                // assumes we are loading our own graph, via the parquet loaders,
+                // so previous calls have already stored the node ids and types
+                if resolve_nodes {
+                    store_node_ids(&gid_str_cache, locked_page);
+                }
+
+                if resolve_nodes {
+                    add_and_resolve_outbound_edges(
+                        &eids_exist,
+                        &layer_eids_exist,
+                        &eid_col_shared,
+                        &edge_segments_touched,
+                        max_edge_page_len,
+                        next_edge_id,
+                        edges,
+                        locked_page,
+                        zip,
+                        delete,
+                    );
+                } else if let Some(edge_ids) = eids {
+                    add_and_resolve_outbound_edges(
+                        &eids_exist,
+                        &layer_eids_exist,
+                        &eid_col_shared,
+                        &edge_segments_touched,
+                        max_edge_page_len,
+                        |row| {
+                            let eid = EID(edge_ids[row] as usize);
+                            arc_edges.increment_edge_segment_count(eid);
+                            eid
+                        },
+                        edges,
+                        locked_page,
+                        zip,
+                        delete,
+                    );
+                }
+            });
+
+        write_locked_graph
+            .nodes
+            .par_iter_mut()
+            .enumerate()
+            .for_each(|(segment_id, shard)| {
+                if !node_segments_touched[segment_id].load(Ordering::Relaxed) {
+                    // we still need the writer in case we need to flush
+                    if shard.segment().is_dirty() {
+                        let mut _writer = shard.writer();
+                    }
+                    return;
+                }
+
+                let zip = izip!(
+                    src_vids.iter(),
+                    dst_vids.iter(),
+                    eid_col_resolved.iter(),
+                    time_col.iter(),
+                    secondary_index_col.iter(),
+                    layer_col_resolved.iter(),
+                    layer_eids_exist.iter().map(|a| a.load(Ordering::Relaxed)),
+                    eids_exist.iter().map(|b| b.load(Ordering::Relaxed))
+                );
+
+                update_inbound_edges(shard, zip, delete);
+                node_segments_touched[segment_id].store(false, Ordering::Relaxed)
+            });
+
+        drop(write_locked_graph);
+        let mut write_locked_graph = graph.write_lock().map_err(into_graph_err)?;
+
+        edge_segments_touched.resize_with(write_locked_graph.edges.len(), || AtomicBool::new(true));
+
+        write_locked_graph
+            .edges
+            .par_iter_mut()
+            .enumerate()
+            .for_each(|(segment_id, shard)| {
+                if !edge_segments_touched[segment_id].load(Ordering::Relaxed) {
+                    // we still need the writer in case we need to flush
+                    if shard.page().is_dirty() {
+                        let mut _writer = shard.writer();
+                        return;
+                    }
+                }
+
+                let zip = izip!(
+                    src_vids.iter(),
+                    dst_vids.iter(),
+                    time_col.iter(),
+                    secondary_index_col.iter(),
+                    eid_col_resolved.iter(),
+                    layer_col_resolved.iter(),
+                    eids_exist
+                        .iter()
+                        .map(|exists| exists.load(Ordering::Relaxed))
+                );
+                update_edge_properties(
+                    &shared_metadata,
+                    &prop_cols,
+                    &metadata_cols,
+                    shard,
+                    zip,
+                    delete,
+                );
+                edge_segments_touched[segment_id].store(false, Ordering::Relaxed)
+            });
+
+        #[cfg(feature = "progress")]
+        let _ = pb.update(df.len());
+    }
+    Ok::<_, GraphError>(())
+}
+
+#[allow(clippy::too_many_arguments, clippy::type_complexity)]
+pub fn get_or_resolve_node_vids<
+    'a: 'c,
+    'b: 'c,
+    'c,
+    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps,
+>(
+    graph: &G,
+    src_index: usize,
+    dst_index: usize,
+    src_col_resolved: &'a mut Vec<VID>,
+    dst_col_resolved: &'a mut Vec<VID>,
+    resolve_nodes: bool,
+    df: &'b DFChunk,
+    src_col: &'a NodeCol,
+    dst_col: &'a NodeCol,
+) -> Result<(&'c [VID], &'c [VID], Vec<(GidRef<'a>, VID)>), GraphError> {
+    let (src_vids, dst_vids, gid_str_cache) = if resolve_nodes {
+        src_col_resolved.resize_with(df.len(), Default::default);
+        dst_col_resolved.resize_with(df.len(), Default::default);
+
+        let atomic_src_col = atomic_vid_from_mut_slice(src_col_resolved);
+        let atomic_dst_col = atomic_vid_from_mut_slice(dst_col_resolved);
+
+        let gid_str_cache = resolve_nodes_with_cache::<G>(
+            graph,
+            [(src_col), (dst_col)].as_ref(),
+            [atomic_src_col, atomic_dst_col].as_ref(),
+        )?;
+        (
+            src_col_resolved.as_slice(),
+            dst_col_resolved.as_slice(),
+            gid_str_cache.into_iter().collect(),
+        )
+    } else {
+        let srcs = df.chunk[src_index]
+            .as_primitive_opt::<UInt64Type>()
+            .ok_or_else(|| LoadError::InvalidNodeIdType(df.chunk[src_index].data_type().clone()))?
+            .values()
+            .as_ref();
+        let dsts = df.chunk[dst_index]
+            .as_primitive_opt::<UInt64Type>()
+            .ok_or_else(|| LoadError::InvalidNodeIdType(df.chunk[dst_index].data_type().clone()))?
+            .values()
+            .as_ref();
+        (
+            bytemuck::cast_slice(srcs),
+            bytemuck::cast_slice(dsts),
+            vec![],
+        )
+    };
+    Ok((src_vids, dst_vids, gid_str_cache))
+}
+
+fn update_edge_properties<'a, ES: EdgeSegmentOps<Extension = Extension>>(
+    shared_metadata: &[(usize, Prop)],
+    prop_cols: &PropCols,
+    metadata_cols: &PropCols,
+    shard: &mut LockedEdgePage<'_, ES>,
+    zip: impl Iterator<Item = (&'a VID, &'a VID, i64, usize, &'a EID, &'a usize, bool)>,
+    delete: bool,
+) {
+    let mut t_props = vec![];
+    let mut c_props = vec![];
+    let mut writer = shard.writer();
+
+    for (row, (src, dst, time, secondary_index, eid, layer, exists)) in zip.enumerate() {
+        if let Some(eid_pos) = writer.resolve_pos(*eid) {
+            let t = EventTime(time, secondary_index);
+
+            t_props.clear();
+            t_props.extend(prop_cols.iter_row(row));
+
+            c_props.clear();
+            c_props.extend(metadata_cols.iter_row(row));
+            c_props.extend(
+                shared_metadata
+                    .iter()
+                    .map(|(id, prop)| (*id, prop.as_prop_ref())),
+            );
+
+            if !delete {
+                writer.bulk_add_edge(
+                    t,
+                    eid_pos,
+                    *src,
+                    *dst,
+                    exists,
+                    LayerId(*layer),
+                    c_props.drain(..),
+                    t_props.drain(..),
+                );
+            } else {
+                writer.bulk_delete_edge(t, eid_pos, *src, *dst, exists, LayerId(*layer));
+            }
+        }
+    }
+}
+
+fn update_inbound_edges<'a, NS: NodeSegmentOps<Extension = Extension>>(
+    shard: &mut LockedNodePage<'_, NS>,
+    zip: impl Iterator<Item = (&'a VID, &'a VID, &'a EID, i64, usize, &'a usize, bool, bool)>,
+    delete: bool,
+) {
+    let mut writer = shard.writer();
+    for (
+        src,
+        dst,
+        eid,
+        time,
+        secondary_index,
+        layer,
+        edge_exists_in_layer,
+        edge_exists_in_static_graph,
+    ) in zip
+    {
+        if let Some(dst_pos) = writer.resolve_pos(*dst) {
+            let t = EventTime(time, secondary_index);
+
+            if !edge_exists_in_static_graph {
+                writer.add_static_inbound_edge(dst_pos, *src, *eid);
+            }
+            let elid = if delete {
+                eid.with_layer_deletion(LayerId(*layer))
+            } else {
+                eid.with_layer(LayerId(*layer))
+            };
+
+            if src != dst {
+                if edge_exists_in_layer {
+                    writer.update_timestamp(t, dst_pos, elid);
+                } else {
+                    writer.add_inbound_edge(Some(t), dst_pos, *src, elid);
+                }
+            } else {
+                // self-loop edge, only add once
+                if !edge_exists_in_layer {
+                    writer.add_inbound_edge::<i64>(None, dst_pos, *src, elid);
+                }
+            }
+        }
+    }
+}
+
+#[allow(clippy::type_complexity, clippy::too_many_arguments)]
+fn add_and_resolve_outbound_edges<
+    'a,
+    EXT: PersistenceStrategy<NS = NS, ES = ES>,
+    NS: NodeSegmentOps<Extension = EXT>,
+    ES: EdgeSegmentOps<Extension = EXT>,
+>(
+    eids_exist: &[AtomicBool],
+    layer_eids_exist: &[AtomicBool],
+    eid_col_shared: &&mut [AtomicUsize],
+    edge_touched_segments: &[AtomicBool],
+    max_edge_page_len: u32,
+    next_edge_id: impl Fn(usize) -> EID,
+    edges: &WriteLockedEdgePages<'_, ES>,
+    locked_page: &mut LockedNodePage<'_, NS>,
+    zip: impl Iterator<Item = (&'a VID, &'a VID, i64, usize, &'a usize)>,
+    delete: bool,
+) {
+    let mut writer = locked_page.writer();
+    let mut last_edge_segment = usize::MAX;
+    for (row, (src, dst, time, secondary_index, layer)) in zip.enumerate() {
+        if let Some(src_pos) = writer.resolve_pos(*src) {
+            let t = EventTime(time, secondary_index);
+            // find the original EID in the static graph if it exists
+            // otherwise create a new one
+
+            let edge_id = if let Some(edge_id) = writer.get_out_edge(src_pos, *dst, LayerId(0)) {
+                eid_col_shared[row].store(edge_id.0, Ordering::Relaxed);
+                eids_exist[row].store(true, Ordering::Relaxed);
+                MaybeNew::Existing(edge_id)
+            } else {
+                let edge_id = next_edge_id(row);
+                writer.add_static_outbound_edge(src_pos, *dst, edge_id);
+                eid_col_shared[row].store(edge_id.0, Ordering::Relaxed);
+                eids_exist[row].store(false, Ordering::Relaxed);
+                MaybeNew::New(edge_id)
+            };
+
+            let edge_id = edge_id.map(|eid| {
+                if delete {
+                    eid.with_layer_deletion(LayerId(*layer))
+                } else {
+                    eid.with_layer(LayerId(*layer))
+                }
+            });
+
+            let (edge_segment, _) = resolve_pos(edge_id.inner().edge, max_edge_page_len);
+            if edge_segment != last_edge_segment {
+                if let Some(touched) = edge_touched_segments.get(edge_segment) {
+                    touched.store(true, Ordering::Relaxed);
+                }
+            }
+            last_edge_segment = edge_segment;
+
+            let exists = !edge_id.is_new()
+                && (edges.exists(edge_id.inner())
+                    || writer
+                        .get_out_edge(src_pos, *dst, edge_id.inner().layer())
+                        .is_some());
+
+            layer_eids_exist[row].store(exists, Ordering::Relaxed);
+
+            if exists {
+                writer.update_timestamp(t, src_pos, edge_id.inner());
+            } else {
+                writer.add_outbound_edge(Some(t), src_pos, *dst, edge_id.inner());
+            }
+        }
+    }
+}
+
+pub fn store_node_ids<NS: NodeSegmentOps<Extension = Extension>>(
+    gid_str_cache: &[(GidRef<'_>, VID)],
+    locked_page: &mut LockedNodePage<'_, NS>,
+) {
+    let mut writer = locked_page.writer();
+    for (src_gid, vid) in gid_str_cache.iter() {
+        if let Some(src_pos) = writer.resolve_pos(*vid) {
+            writer.store_node_id(src_pos, STATIC_GRAPH_LAYER_ID, (*src_gid).into());
+        }
+    }
+}
diff --git a/raphtory/src/io/arrow/df_loaders/mod.rs b/raphtory/src/io/arrow/df_loaders/mod.rs
new file mode 100644
index 0000000000..b0183b4869
--- /dev/null
+++ b/raphtory/src/io/arrow/df_loaders/mod.rs
@@ -0,0 +1,358 @@
+use crate::{
+    db::api::view::StaticGraphViewOps,
+    errors::{into_graph_err, GraphError},
+    io::arrow::{
+        dataframe::{DFChunk, DFView, SecondaryIndexCol},
+        df_loaders::edges::ColumnNames,
+        node_col::NodeCol,
+        prop_handler::*,
+    },
+    prelude::*,
+};
+use kdam::{Bar, BarBuilder, BarExt};
+use raphtory_api::core::{
+    entities::properties::prop::PropType,
+    storage::{dict_mapper::MaybeNew, timeindex::EventTime, FxDashMap},
+};
+use raphtory_core::entities::{GidRef, VID};
+use raphtory_storage::mutation::addition_ops::{InternalAdditionOps, SessionAdditionOps};
+use rayon::prelude::*;
+use std::{
+    collections::HashMap,
+    env,
+    sync::atomic::{AtomicUsize, Ordering},
+};
+
+pub mod edge_props;
+pub mod edges;
+pub mod nodes;
+
+#[cfg(feature = "progress")]
+fn progress_bars_enabled() -> bool {
+    env::var("RAPHTORY_PROGRESS_BARS_ENABLED")
+        .ok()
+        .and_then(|value| {
+            let value = value.trim().to_ascii_lowercase();
+            match value.as_str() {
+                "false" | "0" => Some(false),
+                "true" | "1" => Some(true),
+                _ => None,
+            }
+        })
+        .unwrap_or(true)
+}
+
+#[cfg(feature = "progress")]
+fn build_progress_bar(des: String, num_rows: Option<usize>) -> Result<Bar, GraphError> {
+    let mut bar_builder = BarBuilder::default()
+        .desc(des)
+        .animation(kdam::Animation::FillUp)
+        .unit_scale(true);
+
+    if let Some(num_rows) = num_rows {
+        bar_builder = bar_builder.total(num_rows);
+    }
+
+    if !progress_bars_enabled() {
+        bar_builder = bar_builder.disable(true);
+    }
+
+    bar_builder.build().map_err(|_| GraphError::TqdmError)
+}
+
+fn process_shared_properties(
+    props: Option<&HashMap<String, Prop>>,
+    resolver: impl Fn(&str, PropType) -> Result<MaybeNew<usize>, GraphError>,
+) -> Result<Vec<(usize, Prop)>, GraphError> {
+    match props {
+        None => Ok(vec![]),
+        Some(props) => props
+            .iter()
+            .map(|(key, prop)| Ok((resolver(key, prop.dtype())?.inner(), prop.clone())))
+            .collect(),
+    }
+}
+
+pub(crate) fn load_edge_deletions_from_df_prefetch<
+    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps + DeletionOps,
+>(
+    df_view: DFView<impl Iterator<Item = Result<DFChunk, GraphError>> + Send>,
+    column_names: ColumnNames,
+    resolve_nodes: bool,
+    layer: Option<&str>,
+    graph: &G,
+) -> Result<(), GraphError> {
+    edges::load_edges_from_df_prefetch(
+        df_view,
+        column_names,
+        resolve_nodes,
+        &[],
+        &[],
+        None,
+        layer,
+        graph,
+        true,
+    )
+}
+
+pub(crate) fn load_edge_deletions_from_df<
+    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps + DeletionOps,
+>(
+    df_view: DFView<impl Iterator<Item = Result<DFChunk, GraphError>>>,
+    column_names: ColumnNames,
+    resolve_nodes: bool,
+    layer: Option<&str>,
+    graph: &G,
+) -> Result<(), GraphError> {
+    edges::load_edges_from_df(
+        df_view,
+        column_names,
+        resolve_nodes,
+        &[],
+        &[],
+        None,
+        layer,
+        graph,
+        true,
+    )
+}
+
+pub(crate) fn load_edges_props_from_df_prefetch<
+    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps,
+>(
+    df_view: DFView<impl Iterator<Item = Result<DFChunk, GraphError>> + Send>,
+    src: &str,
+    dst: &str,
+    metadata: &[&str],
+    shared_metadata: Option<&HashMap<String, Prop>>,
+    layer: Option<&str>,
+    layer_col: Option<&str>,
+    graph: &G,
+    resolve_nodes: bool,
+) -> Result<(), GraphError> {
+    edge_props::load_edges_from_df_prefetch(
+        df_view,
+        ColumnNames::new("", None, src, dst, layer_col),
+        resolve_nodes,
+        metadata,
+        shared_metadata,
+        layer,
+        graph,
+    )
+}
+
+pub(crate) fn load_graph_props_from_df<
+    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps,
+>(
+    df_view: DFView<impl Iterator<Item = Result<DFChunk, GraphError>>>,
+    time: &str,
+    secondary_index: Option<&str>,
+    properties: Option<&[&str]>,
+    metadata: Option<&[&str]>,
+    graph: &G,
+) -> Result<(), GraphError> {
+    if df_view.is_empty() {
+        return Ok(());
+    }
+    let properties = properties.unwrap_or(&[]);
+    let metadata = metadata.unwrap_or(&[]);
+
+    let properties_indices = properties
+        .iter()
+        .map(|name| df_view.get_index(name))
+        .collect::<Result<Vec<_>, GraphError>>()?;
+    let metadata_indices = metadata
+        .iter()
+        .map(|name| df_view.get_index(name))
+        .collect::<Result<Vec<_>, GraphError>>()?;
+
+    let time_index = df_view.get_index(time)?;
+    let secondary_index_index = secondary_index
+        .map(|col| df_view.get_index(col))
+        .transpose()?;
+
+    #[cfg(feature = "progress")]
+    let mut pb = build_progress_bar("Loading graph properties".to_string(), df_view.num_rows)?;
+    let session = graph.write_session().map_err(into_graph_err)?;
+
+    for chunk in df_view.chunks {
+        let df = chunk?;
+        let prop_cols =
+            combine_properties_arrow(properties, &properties_indices, &df, |key, dtype| {
+                session
+                    .resolve_graph_property(key, dtype, false)
+                    .map_err(into_graph_err)
+            })?;
+        let metadata_cols =
+            combine_properties_arrow(metadata, &metadata_indices, &df, |key, dtype| {
+                session
+                    .resolve_graph_property(key, dtype, true)
+                    .map_err(into_graph_err)
+            })?;
+        let time_col = df.time_col(time_index)?;
+
+        // Load the secondary index column if it exists, otherwise generate from start_id.
+        let secondary_index_col = match secondary_index_index {
+            Some(col_index) => {
+                // Update the event_id to reflect ingesting new secondary indices.
+                let col = df.secondary_index_col(col_index)?;
+                session
+                    .set_max_event_id(col.max())
+                    .map_err(into_graph_err)?;
+                col
+            }
+            None => {
+                let start_id = session
+                    .reserve_event_ids(df.len())
+                    .map_err(into_graph_err)?;
+                SecondaryIndexCol::new_from_range(start_id, start_id + df.len())
+            }
+        };
+
+        time_col
+            .par_iter()
+            .zip(secondary_index_col.par_iter())
+            .zip(prop_cols.par_rows())
+            .zip(metadata_cols.par_rows())
+            .try_for_each(|(((time, secondary_index), t_props), c_props)| {
+                let t = EventTime(time, secondary_index);
+                let t_props: Vec<_> = t_props.collect();
+
+                if !t_props.is_empty() {
+                    graph
+                        .internal_add_properties(t, &t_props)
+                        .map_err(into_graph_err)?;
+                }
+
+                let c_props: Vec<_> = c_props.collect();
+
+                if !c_props.is_empty() {
+                    graph
+                        .internal_add_metadata(&c_props)
+                        .map_err(into_graph_err)?;
+                }
+
+                Ok::<(), GraphError>(())
+            })?;
+
+        #[cfg(feature = "progress")]
+        let _ = pb.update(df.len());
+    }
+
+    Ok(())
+}
+
+pub(crate) fn extract_secondary_index_col<G: InternalAdditionOps + AdditionOps>(
+    secondary_index_index: Option<usize>,
+    session: &<G as InternalAdditionOps>::WS<'_>,
+    df: &DFChunk,
+) -> Result<SecondaryIndexCol, GraphError> {
+    let secondary_index_col = match secondary_index_index {
+        Some(col_index) => {
+            // Update the event_id to reflect ingesting new secondary indices.
+            let col = df.secondary_index_col(col_index)?;
+            session
+                .set_max_event_id(col.max())
+                .map_err(into_graph_err)?;
+            col
+        }
+        None => {
+            let start_id = session
+                .reserve_event_ids(df.len())
+                .map_err(into_graph_err)?;
+            SecondaryIndexCol::new_from_range(start_id, start_id + df.len())
+        }
+    };
+    Ok(secondary_index_col)
+}
+
+fn resolve_nodes_with_cache<'a, G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps>(
+    graph: &G,
+    cols_to_resolve: &[&'a NodeCol],
+    resolved_cols: &[&mut [AtomicUsize]],
+) -> Result<FxDashMap<GidRef<'a>, VID>, GraphError> {
+    resolve_nodes_with_cache_generic(
+        cols_to_resolve,
+        |vid: &VID, idx, col_idx| {
+            resolved_cols[col_idx][idx].store(vid.0, Ordering::Relaxed);
+        },
+        |gid, _, _| {
+            let vid = unsafe { graph.bulk_load_resolve_node(gid).map_err(into_graph_err)? };
+            Ok(vid)
+        },
+    )
+}
+
+fn resolve_nodes_and_type_with_cache<
+    'a,
+    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps,
+>(
+    graph: &G,
+    cols_to_resolve: &[&'a NodeCol],
+    node_types: &[&'a [usize]],
+    resolved_cols: &[&mut [AtomicUsize]],
+) -> Result<FxDashMap<GidRef<'a>, (VID, usize)>, GraphError> {
+    resolve_nodes_with_cache_generic(
+        cols_to_resolve,
+        |vid: &(VID, usize), row, col_idx| {
+            let (vid, _) = vid;
+            resolved_cols[col_idx][row].store(vid.index(), Ordering::Relaxed);
+        },
+        |gid, row, col_idx| {
+            let vid = unsafe { graph.bulk_load_resolve_node(gid).map_err(into_graph_err)? };
+            let node_type = node_types[col_idx][row];
+            Ok((vid, node_type))
+        },
+    )
+}
+
+fn resolve_nodes_with_cache_generic<'a, V: Send + Sync>(
+    cols_to_resolve: &[&'a NodeCol],
+    update_fn: impl Fn(&V, usize, usize) + Send + Sync,
+    new_fn: impl Fn(GidRef<'a>, usize, usize) -> Result<V, GraphError> + Send + Sync,
+) -> Result<FxDashMap<GidRef<'a>, V>, GraphError> {
+    let gid_str_cache: dashmap::DashMap<GidRef<'_>, V, _> = FxDashMap::default();
+    let hasher_factory = gid_str_cache.hasher().clone();
+    gid_str_cache
+        .shards()
+        .par_iter()
+        .enumerate()
+        .try_for_each(|(shard_idx, shard)| {
+            let mut shard_guard = shard.write();
+            use dashmap::SharedValue;
+            use std::hash::BuildHasher;
+
+            // Create hasher function for this shard
+            let hash_key = |key: &GidRef<'_>| -> u64 { hasher_factory.hash_one(key) };
+
+            let hasher_fn =
+                |tuple: &(GidRef<'_>, SharedValue<V>)| -> u64 { hasher_factory.hash_one(tuple.0) };
+
+            for (col_id, node_col) in cols_to_resolve.iter().enumerate() {
+                // Process src_col sequentially for this shard
+                for (row, gid) in node_col.iter().enumerate() {
+                    // Check if this key belongs to this shard
+                    if gid_str_cache.determine_map(&gid) != shard_idx {
+                        continue; // Skip, not our shard
+                    }
+
+                    let hash = hash_key(&gid);
+
+                    // Check if exists in this shard
+                    if let Some((_, value)) = shard_guard.get(hash, |(g, _)| g == &gid) {
+                        let v = value.get();
+                        update_fn(v, row, col_id);
+                    } else {
+                        let v = new_fn(gid, row, col_id)?;
+
+                        update_fn(&v, row, col_id);
+                        let data = (gid, SharedValue::new(v));
+                        shard_guard.insert(hash, data, hasher_fn);
+                    }
+                }
+            }
+
+            Ok::<(), GraphError>(())
+        })?;
+    Ok(gid_str_cache)
+}
diff --git a/raphtory/src/io/arrow/df_loaders/nodes.rs b/raphtory/src/io/arrow/df_loaders/nodes.rs
new file mode 100644
index 0000000000..f3c23f9869
--- /dev/null
+++ b/raphtory/src/io/arrow/df_loaders/nodes.rs
@@ -0,0 +1,578 @@
+use crate::{
+    core::entities::nodes::node_ref::AsNodeRef,
+    db::api::view::StaticGraphViewOps,
+    errors::{into_graph_err, GraphError, LoadError},
+    io::{
+        arrow::{
+            dataframe::{DFChunk, DFView},
+            df_loaders::{
+                extract_secondary_index_col, process_shared_properties,
+                resolve_nodes_and_type_with_cache,
+            },
+            layer_col::{lift_layer_col, lift_node_type_col, LayerCol},
+            node_col::NodeCol,
+            prop_handler::*,
+        },
+        LOAD_POOL,
+    },
+    prelude::*,
+};
+use arrow::{array::AsArray, datatypes::UInt64Type};
+use itertools::izip;
+use raphtory_api::{
+    atomic_extra::atomic_vid_from_mut_slice,
+    core::{
+        entities::{
+            properties::{meta::STATIC_GRAPH_LAYER_ID, prop::AsPropRef},
+            LayerId,
+        },
+        storage::timeindex::EventTime,
+    },
+};
+use raphtory_core::{
+    entities::{GidRef, VID},
+    storage::timeindex::AsTime,
+};
+use raphtory_storage::mutation::addition_ops::{InternalAdditionOps, SessionAdditionOps};
+use rayon::prelude::*;
+use std::{
+    collections::HashMap,
+    sync::atomic::{AtomicBool, Ordering},
+};
+use storage::{
+    api::nodes::NodeSegmentOps,
+    pages::{locked::nodes::LockedNodePage, resolve_pos},
+    Extension,
+};
+
+#[cfg(feature = "progress")]
+use crate::io::arrow::df_loaders::build_progress_bar;
+
+#[cfg(feature = "progress")]
+use kdam::BarExt;
+
+#[allow(clippy::too_many_arguments)]
+pub fn load_nodes_from_df<
+    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps + std::fmt::Debug,
+>(
+    df_view: DFView<impl Iterator<Item = Result<DFChunk, GraphError>> + Send>,
+    time: &str,
+    secondary_index: Option<&str>,
+    node_id: &str,
+    properties: &[&str],
+    metadata: &[&str],
+    shared_metadata: Option<&HashMap<String, Prop>>,
+    node_type: Option<&str>,
+    node_type_col: Option<&str>,
+    graph: &G,
+    resolve_nodes: bool,
+    layer_id: Option<&str>,
+    layer_id_col: Option<&str>,
+) -> Result<(), GraphError> {
+    if df_view.is_empty() {
+        return Ok(());
+    }
+
+    LOAD_POOL.install(move || {
+        let properties_indices = properties
+            .iter()
+            .map(|name| df_view.get_index(name))
+            .collect::<Result<Vec<_>, GraphError>>()?;
+        let metadata_indices = metadata
+            .iter()
+            .map(|name| df_view.get_index(name))
+            .collect::<Result<Vec<_>, GraphError>>()?;
+
+        let node_type_index =
+            node_type_col.map(|node_type_col| df_view.get_index(node_type_col.as_ref()));
+        let node_type_index = node_type_index.transpose()?;
+        let layer_index = layer_id_col
+            .map(|name| df_view.get_index(name))
+            .transpose()?;
+
+        let node_id_index = df_view.get_index(node_id)?;
+        let time_index = df_view.get_index(time)?;
+        let secondary_index_index = secondary_index
+            .map(|col| df_view.get_index(col))
+            .transpose()?;
+
+        let session = graph.write_session().map_err(into_graph_err)?;
+        let shared_metadata = process_shared_properties(shared_metadata, |key, dtype| {
+            session
+                .resolve_node_property(key, dtype, true)
+                .map_err(into_graph_err)
+        })?;
+
+        #[cfg(feature = "progress")]
+        let mut pb = build_progress_bar("Loading nodes".to_string(), df_view.num_rows)?;
+
+        let mut node_col_resolved = vec![];
+
+        let mut node_segments_touched = (0..graph.core_graph().num_node_segments())
+            .map(|_| AtomicBool::new(false))
+            .collect::<Vec<_>>();
+
+        for chunk in df_view.chunks {
+            let df = chunk?;
+            let prop_cols =
+                combine_properties_arrow(properties, &properties_indices, &df, |key, dtype| {
+                    session
+                        .resolve_node_property(key, dtype, false)
+                        .map_err(into_graph_err)
+                })?;
+            let metadata_cols =
+                combine_properties_arrow(metadata, &metadata_indices, &df, |key, dtype| {
+                    session
+                        .resolve_node_property(key, dtype, true)
+                        .map_err(into_graph_err)
+                })?;
+            let node_type_col = lift_node_type_col(node_type, node_type_index, &df)?;
+            let node_type_col_resolved = node_type_col.resolve_node_type(graph)?;
+            // When no layer is specified, node properties go to STATIC_GRAPH_LAYER_ID.
+            // resolve_layer(None) would return "_default" (LayerId 1), which is wrong for nodes.
+            let layer_col_resolved = if layer_id.is_some() || layer_index.is_some() {
+                let layer_col = lift_layer_col(layer_id, layer_index, &df)?;
+                Some(layer_col.resolve_layer(None, graph)?)
+            } else {
+                None
+            };
+
+            let time_col = df.time_col(time_index)?;
+            let node_col = df.node_col(node_id_index)?;
+
+            // Load the secondary index column if it exists, otherwise generate from start_id.
+            let secondary_index_col =
+                extract_secondary_index_col::<G>(secondary_index_index, &session, &df)?;
+            node_col_resolved.resize_with(df.len(), Default::default);
+
+            let (src_vids, gid_str_cache) = get_or_resolve_node_vids::<G>(
+                graph,
+                node_id_index,
+                &mut node_col_resolved,
+                &node_type_col_resolved,
+                resolve_nodes,
+                &df,
+                &node_col,
+            )?;
+
+            let mut write_locked_graph = graph.write_lock().map_err(into_graph_err)?;
+            node_segments_touched
+                .resize_with(write_locked_graph.nodes.len(), || AtomicBool::new(true));
+
+            let max_node_segment_len = write_locked_graph
+                .graph()
+                .storage()
+                .nodes()
+                .max_segment_len() as usize;
+
+            if !gid_str_cache.is_empty() {
+                for (_, (vid, _)) in &gid_str_cache {
+                    let (node_segment, _) = resolve_pos(vid.index(), max_node_segment_len as u32);
+                    node_segments_touched[node_segment].store(true, Ordering::Relaxed);
+                }
+            } else {
+                let mut last_vid = VID::default();
+                for vid in src_vids {
+                    if *vid != last_vid {
+                        let (node_segment, _) =
+                            resolve_pos(vid.index(), max_node_segment_len as u32);
+                        node_segments_touched[node_segment].store(true, Ordering::Relaxed);
+                    }
+                    last_vid = *vid
+                }
+            }
+
+            let node_stats = write_locked_graph.node_stats().clone();
+            let update_time = |time: EventTime| {
+                let time = time.t();
+                node_stats.update_time(time);
+            };
+
+            write_locked_graph
+                .nodes
+                .par_iter_mut()
+                .enumerate()
+                .try_for_each(|(segment_id, shard)| {
+                    if !node_segments_touched[segment_id].load(Ordering::Relaxed) {
+                        // we need to graph a writer nevertheless as it may have old data that needs to flush
+                        if shard.segment().is_dirty() {
+                            let mut _writer = shard.writer();
+                        }
+                        return Ok::<_, GraphError>(());
+                    }
+                    // Zip all columns for iteration.
+                    let zip = izip!(src_vids.iter(), time_col.iter(), secondary_index_col.iter(),);
+
+                    // resolve_nodes=false
+                    // assumes we are loading our own graph, via the parquet loaders,
+                    // so previous calls have already stored the node ids and types
+                    if resolve_nodes {
+                        store_node_ids_and_type(&gid_str_cache, shard);
+                    }
+                    let mut writer = shard.writer();
+
+                    for (row, (vid, time, secondary_index)) in zip.enumerate() {
+                        if let Some(mut_node) = writer.resolve_pos(*vid) {
+                            let t = EventTime(time, secondary_index);
+                            let layer_id = layer_col_resolved
+                                .as_ref()
+                                .map_or(STATIC_GRAPH_LAYER_ID, |r| LayerId(r[row]));
+
+                            update_time(t);
+
+                            let t_props = prop_cols.iter_row(row);
+                            let c_props = metadata_cols.iter_row(row).chain(
+                                shared_metadata
+                                    .iter()
+                                    .map(|(id, prop)| (*id, prop.as_prop_ref())),
+                            );
+
+                            writer.add_props(t, mut_node, layer_id, t_props);
+                            writer.update_c_props(mut_node, layer_id, c_props);
+                        };
+                    }
+
+                    node_segments_touched[segment_id].store(false, Ordering::Relaxed);
+                    Ok::<_, GraphError>(())
+                })?;
+
+            #[cfg(feature = "progress")]
+            let _ = pb.update(df.len());
+        }
+        Ok::<_, GraphError>(())
+    })?;
+
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn load_node_props_from_df<
+    'a,
+    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps + std::fmt::Debug,
+>(
+    df_view: DFView<impl Iterator<Item = Result<DFChunk, GraphError>>>,
+    node_id: &str,
+    node_type: Option<&str>,
+    node_type_col: Option<&str>,
+    node_id_col: Option<&str>,      // provided by our parquet encoder
+    node_type_id_col: Option<&str>, // provided by our parquet encoder
+    metadata: &[&str],
+    shared_metadata: Option<&HashMap<String, Prop>>,
+    graph: &G,
+) -> Result<(), GraphError> {
+    if df_view.is_empty() {
+        return Ok(());
+    }
+    let metadata_indices = metadata
+        .iter()
+        .map(|name| df_view.get_index(name))
+        .collect::<Result<Vec<_>, GraphError>>()?;
+
+    let node_type_index =
+        node_type_col.map(|node_type_col| df_view.get_index(node_type_col.as_ref()));
+    let node_type_index = node_type_index.transpose()?;
+    let node_type_ids_col = node_type_id_col
+        .map(|node_type_id_col| df_view.get_index(node_type_id_col.as_ref()))
+        .transpose()?;
+
+    let node_id_index = node_id_col
+        .map(|node_col| df_view.get_index(node_col.as_ref()))
+        .transpose()?;
+
+    let node_gid_index = df_view.get_index(node_id)?;
+    let session = graph.write_session().map_err(into_graph_err)?;
+
+    let shared_metadata = process_shared_properties(shared_metadata, |key, dtype| {
+        session
+            .resolve_node_property(key, dtype, true)
+            .map_err(into_graph_err)
+    })?;
+
+    let resolve_nodes = node_type_ids_col.is_some() && node_id_index.is_some();
+
+    #[cfg(feature = "progress")]
+    let mut pb = build_progress_bar("Loading node properties".to_string(), df_view.num_rows)?;
+
+    let mut node_col_resolved = vec![];
+    let mut node_type_resolved = vec![];
+
+    for chunk in df_view.chunks {
+        let df = chunk?;
+        if df.is_empty() {
+            continue;
+        }
+        let metadata_cols =
+            combine_properties_arrow(metadata, &metadata_indices, &df, |key, dtype| {
+                session
+                    .resolve_node_property(key, dtype, true)
+                    .map_err(into_graph_err)
+            })?;
+        let node_type_col = lift_node_type_col(node_type, node_type_index, &df)?;
+        let node_col = df.node_col(node_gid_index)?;
+
+        let (node_col_resolved, node_type_col_resolved) = get_or_resolve_node_vids_no_events::<G>(
+            graph,
+            &session,
+            &mut node_col_resolved,
+            &mut node_type_resolved,
+            node_type_ids_col,
+            node_id_index,
+            &df,
+            &node_col,
+            node_type_col,
+        )?;
+
+        // We assume this is fast enough
+        let max_vid = node_col_resolved
+            .iter()
+            .filter(|vid| vid.is_initialised())
+            .map(|vid| vid.index())
+            .max()
+            .map(VID)
+            .unwrap_or(VID(0));
+        let mut write_locked_graph = graph.write_lock().map_err(into_graph_err)?;
+        write_locked_graph.resize_segments_to_vid(max_vid);
+
+        write_locked_graph
+            .nodes
+            .par_iter_mut()
+            .try_for_each(|shard| {
+                let mut c_props = vec![];
+
+                let mut writer = shard.writer();
+                for (idx, ((vid, node_type), gid)) in node_col_resolved
+                    .iter()
+                    .zip(node_type_col_resolved.iter())
+                    .zip(node_col.iter())
+                    .enumerate()
+                    .filter(|(_, ((vid, _), _))| vid.is_initialised())
+                // filter out unresolved vids
+                {
+                    if let Some(mut_node) = writer.resolve_pos(*vid) {
+                        writer.store_node_id_and_node_type(
+                            mut_node,
+                            STATIC_GRAPH_LAYER_ID,
+                            gid,
+                            *node_type,
+                        );
+
+                        if resolve_nodes {
+                            // because we don't call resolve_node above
+                            writer.increment_seg_num_nodes()
+                        }
+
+                        c_props.clear();
+                        c_props.extend(metadata_cols.iter_row(idx));
+                        c_props.extend(shared_metadata.iter().map(|(i, p)| (*i, p.as_prop_ref())));
+
+                        if !c_props.is_empty() {
+                            writer.update_c_props(
+                                mut_node,
+                                STATIC_GRAPH_LAYER_ID,
+                                c_props.drain(..),
+                            );
+                        }
+                    };
+                }
+
+                Ok::<_, GraphError>(())
+            })?;
+
+        #[cfg(feature = "progress")]
+        let _ = pb.update(df.len());
+    }
+    Ok(())
+}
+
+type Resolved<'a> = (GidRef<'a>, (VID, usize));
+#[allow(clippy::too_many_arguments, clippy::type_complexity)]
+fn get_or_resolve_node_vids<
+    'a: 'c,
+    'b: 'c,
+    'c,
+    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps,
+>(
+    graph: &G,
+    src_index: usize,
+    src_col_resolved: &'a mut Vec<VID>,
+    node_type_resolved: &'a [usize],
+    resolve_nodes: bool,
+    df: &'b DFChunk,
+    src_col: &'a NodeCol,
+) -> Result<(&'c [VID], Vec<Resolved<'a>>), GraphError> {
+    let (src_vids, gid_str_cache) = if resolve_nodes {
+        src_col_resolved.resize_with(df.len(), Default::default);
+
+        let atomic_src_col = atomic_vid_from_mut_slice(src_col_resolved);
+
+        let gid_str_cache = resolve_nodes_and_type_with_cache::<G>(
+            graph,
+            [src_col].as_ref(),
+            [node_type_resolved].as_ref(),
+            [atomic_src_col].as_ref(),
+        )?;
+        (
+            src_col_resolved.as_slice(),
+            gid_str_cache.into_iter().collect(),
+        )
+    } else {
+        let srcs = df.chunk[src_index]
+            .as_primitive_opt::<UInt64Type>()
+            .ok_or_else(|| LoadError::InvalidNodeIdType(df.chunk[src_index].data_type().clone()))?
+            .values()
+            .as_ref();
+        (bytemuck::cast_slice(srcs), vec![])
+    };
+    Ok((src_vids, gid_str_cache))
+}
+
+#[allow(clippy::too_many_arguments, clippy::type_complexity)]
+fn get_or_resolve_node_vids_no_events<
+    'a: 'c,
+    'b: 'c,
+    'c,
+    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps,
+>(
+    graph: &G,
+    session: &<G as InternalAdditionOps>::WS<'_>,
+    node_col_resolved: &'a mut Vec<VID>,
+    node_type_resolved: &'a mut Vec<usize>,
+    node_type_ids_col: Option<usize>,
+    node_id_col: Option<usize>,
+    df: &'b DFChunk,
+    src_col: &'a NodeCol,
+    node_type_col: LayerCol<'a>,
+) -> Result<(&'c [VID], &'c [usize]), GraphError> {
+    assert!(!(node_type_ids_col.is_none() ^ node_id_col.is_none())); // both some or both none
+    if let Some((node_type_index, node_id_col)) = node_type_ids_col.zip(node_id_col) {
+        set_meta_for_pre_resolved_nodes_and_node_ids(
+            graph,
+            session,
+            df,
+            src_col,
+            node_type_col,
+            node_type_index,
+            node_id_col,
+        )
+    } else {
+        resolve_node_and_meta_for_node_col(
+            graph,
+            node_col_resolved,
+            node_type_resolved,
+            df,
+            src_col,
+            node_type_col,
+        )
+    }
+}
+
+fn resolve_node_and_meta_for_node_col<
+    'a,
+    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps,
+>(
+    graph: &G,
+    node_col_resolved: &'a mut Vec<VID>,
+    node_type_resolved: &'a mut Vec<usize>,
+    df: &DFChunk,
+    src_col: &NodeCol,
+    node_type_col: LayerCol<'a>,
+) -> Result<(&'a [VID], &'a [usize]), GraphError> {
+    node_col_resolved.resize_with(df.len(), Default::default);
+    node_type_resolved.resize_with(df.len(), Default::default);
+
+    let mut locked_mapper = graph.node_meta().node_type_meta().write();
+
+    let zip = izip!(
+        src_col.iter(),
+        node_type_col.iter(),
+        node_col_resolved.iter_mut(),
+        node_type_resolved.iter_mut()
+    );
+
+    let mut last_node_type: Option<&str> = None;
+    let mut last_node_type_id: Option<usize> = None;
+    for (gid, node_type, vid, node_type_id) in zip {
+        if last_node_type != node_type {
+            if let Some(name) = node_type {
+                let resolved_node_type_id = locked_mapper.get_or_create_id(name).inner();
+                *node_type_id = resolved_node_type_id;
+                last_node_type_id = Some(resolved_node_type_id);
+            } else {
+                *node_type_id = 0;
+                last_node_type_id = Some(0);
+            }
+        } else if let Some(id) = last_node_type_id {
+            *node_type_id = id;
+        }
+
+        let res_vid = graph
+            .internalise_node(gid.as_node_ref())
+            .unwrap_or_default();
+        *vid = res_vid;
+        last_node_type = node_type;
+    }
+
+    Ok((node_col_resolved.as_slice(), node_type_resolved.as_slice()))
+}
+
+fn set_meta_for_pre_resolved_nodes_and_node_ids<
+    'b,
+    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps,
+>(
+    graph: &G,
+    session: &<G as InternalAdditionOps>::WS<'_>,
+    df: &'b DFChunk,
+    src_col: &NodeCol,
+    node_type_col: LayerCol<'_>,
+    node_type_index: usize,
+    node_id_col: usize,
+) -> Result<(&'b [VID], &'b [usize]), GraphError> {
+    let srcs = df.chunk[node_id_col]
+        .as_primitive_opt::<UInt64Type>()
+        .ok_or_else(|| LoadError::InvalidNodeIdType(df.chunk[node_id_col].data_type().clone()))?
+        .values()
+        .as_ref();
+
+    let node_types = df.chunk[node_type_index]
+        .as_primitive_opt::<UInt64Type>()
+        .ok_or_else(|| LoadError::InvalidNodeType(df.chunk[node_type_index].data_type().clone()))?
+        .values()
+        .as_ref();
+
+    let mut locked_mapper = graph.node_meta().node_type_meta().write();
+
+    let zip = izip!(
+        src_col.iter(),
+        srcs.iter(),
+        node_type_col.iter(),
+        node_types.iter()
+    );
+
+    let mut last_node_type: Option<&str> = None;
+
+    for (gid, node_id, node_type, node_type_id) in zip {
+        if last_node_type != node_type {
+            let node_type_name = node_type.unwrap_or("_default");
+            locked_mapper.set_id(node_type_name, *node_type_id as usize);
+        }
+        last_node_type = node_type;
+        session
+            .set_node(gid, VID(*node_id as usize))
+            .map_err(into_graph_err)?;
+    }
+
+    Ok((bytemuck::cast_slice(srcs), bytemuck::cast_slice(node_types)))
+}
+
+#[inline(never)]
+fn store_node_ids_and_type<NS: NodeSegmentOps<Extension = Extension>>(
+    gid_str_cache: &[Resolved<'_>],
+    locked_page: &mut LockedNodePage<'_, NS>,
+) {
+    let mut writer = locked_page.writer();
+    for (gid, (vid, node_type)) in gid_str_cache.iter() {
+        if let Some(src_pos) = writer.resolve_pos(*vid) {
+            writer.store_node_id_and_node_type(src_pos, STATIC_GRAPH_LAYER_ID, *gid, *node_type);
+        }
+    }
+}
diff --git a/raphtory/src/io/arrow/layer_col.rs b/raphtory/src/io/arrow/layer_col.rs
index dbdfdb049e..9a6493325e 100644
--- a/raphtory/src/io/arrow/layer_col.rs
+++ b/raphtory/src/io/arrow/layer_col.rs
@@ -1,3 +1,5 @@
+use std::borrow::Cow;
+
 use crate::{
     errors::{into_graph_err, GraphError, LoadError},
     io::arrow::dataframe::DFChunk,
@@ -7,9 +9,10 @@ use arrow::array::{Array, AsArray, LargeStringArray, StringArray, StringViewArra
 use iter_enum::{
     DoubleEndedIterator, ExactSizeIterator, IndexedParallelIterator, Iterator, ParallelIterator,
 };
+use raphtory_api::core::entities::properties::meta::DEFAULT_NODE_TYPE_ID;
 use rayon::prelude::*;
 
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, Debug)]
 pub(crate) enum LayerCol<'a> {
     Name { name: Option<&'a str>, len: usize },
     Utf8 { col: &'a StringArray },
@@ -62,28 +65,134 @@ impl<'a> LayerCol<'a> {
         }
     }
 
-    pub fn resolve(
+    pub fn get(&self, row: usize) -> Option<&'a str> {
+        match self {
+            LayerCol::Name { name, .. } => *name,
+            LayerCol::Utf8 { col } => {
+                if col.is_valid(row) && row < col.len() {
+                    Some(col.value(row))
+                } else {
+                    None
+                }
+            }
+            LayerCol::LargeUtf8 { col } => {
+                if col.is_valid(row) && row < col.len() {
+                    Some(col.value(row))
+                } else {
+                    None
+                }
+            }
+            LayerCol::Utf8View { col } => {
+                if col.is_valid(row) && row < col.len() {
+                    Some(col.value(row))
+                } else {
+                    None
+                }
+            }
+        }
+    }
+
+    pub fn resolve_node_type<'b>(
         self,
         graph: &(impl AdditionOps + Send + Sync),
-    ) -> Result<Vec<usize>, GraphError> {
+    ) -> Result<Cow<'b, [usize]>, GraphError> {
         match self {
             LayerCol::Name { name, len } => {
-                let layer = graph.resolve_layer(name).map_err(into_graph_err)?.inner();
-                Ok(vec![layer; len])
+                let node_type_id = if let Some(name) = name {
+                    let nt = graph.node_meta().get_or_create_node_type_id(name);
+                    nt.inner()
+                } else {
+                    DEFAULT_NODE_TYPE_ID
+                };
+                Ok(Cow::Owned(vec![node_type_id; len]))
             }
             col => {
-                let iter = col.par_iter();
-                let mut res = vec![0usize; iter.len()];
-                iter.zip(res.par_iter_mut())
-                    .try_for_each(|(layer, entry)| {
-                        let layer = graph.resolve_layer(layer).map_err(into_graph_err)?.inner();
-                        *entry = layer;
-                        Ok::<(), GraphError>(())
-                    })?;
-                Ok(res)
+                let mut res = vec![0usize; col.len()];
+                let node_type_mapper = graph.node_meta().node_type_meta();
+                let mut locked_node_type_mapper = node_type_mapper.write();
+                let mut last = None;
+                let mut last_id = DEFAULT_NODE_TYPE_ID;
+                for (row, name) in col.iter().enumerate() {
+                    let node_type_id = if let Some(name) = name {
+                        if last != Some(name) {
+                            locked_node_type_mapper.get_or_create_id(name).inner()
+                        } else {
+                            last_id
+                        }
+                    } else {
+                        DEFAULT_NODE_TYPE_ID
+                    };
+                    res[row] = node_type_id;
+                    last = name;
+                    last_id = node_type_id;
+                }
+                Ok(Cow::Owned(res))
+            }
+        }
+    }
+
+    pub fn resolve_layer<'b>(
+        self,
+        layer_id_col: Option<&'b [u64]>,
+        graph: &(impl AdditionOps + Send + Sync),
+    ) -> Result<Cow<'b, [usize]>, GraphError> {
+        match (self, layer_id_col) {
+            (LayerCol::Name { name, len }, _) => {
+                let layer = graph.resolve_layer(name).map_err(into_graph_err)?.inner().0;
+                Ok(Cow::Owned(vec![layer; len]))
+            }
+            (col, None) => {
+                let mut res = vec![0usize; col.len()];
+                let mut last_name = None;
+                let mut last_layer = None;
+                for (row, name) in col.iter().enumerate() {
+                    if last_name == name && last_layer.is_some() {
+                        if let Some(layer) = last_layer {
+                            res[row] = layer;
+                        }
+                        continue;
+                    }
+
+                    let layer = graph.resolve_layer(name).map_err(into_graph_err)?.inner().0;
+                    last_layer = Some(layer);
+                    res[row] = layer;
+                    last_name = name;
+                }
+                Ok(Cow::Owned(res))
+            }
+            (col, Some(layer_ids)) => {
+                let mut last_pair = None;
+
+                let edge_layer_mapper = graph.edge_meta().layer_meta();
+                let node_layer_mapper = graph.node_meta().layer_meta();
+
+                let mut locked_edge_lm = edge_layer_mapper.write();
+                let mut locked_node_lm = node_layer_mapper.write();
+
+                for pair @ (name, id) in col
+                    .iter()
+                    .map(|name| name.unwrap_or("_default"))
+                    .zip(layer_ids)
+                {
+                    if last_pair != Some(pair) {
+                        locked_edge_lm.set_id(name, *id as usize);
+                        locked_node_lm.set_id(name, *id as usize);
+                    }
+                    last_pair = Some(pair);
+                }
+                Ok(Cow::Borrowed(bytemuck::cast_slice(layer_ids)))
             }
         }
     }
+
+    pub fn len(&self) -> usize {
+        match self {
+            LayerCol::Name { len, .. } => *len,
+            LayerCol::Utf8 { col } => col.len(),
+            LayerCol::LargeUtf8 { col } => col.len(),
+            LayerCol::Utf8View { col } => col.len(),
+        }
+    }
 }
 
 pub(crate) fn lift_layer_col<'a>(
@@ -127,9 +236,9 @@ pub(crate) fn lift_node_type_col<'a>(
         }),
         (None, Some(layer_index)) => {
             let col = &df.chunk[layer_index];
-            if let Some(col) = col.as_string_opt() {
+            if let Some(col) = col.as_string_opt::<i32>() {
                 Ok(LayerCol::Utf8 { col })
-            } else if let Some(col) = col.as_string_opt() {
+            } else if let Some(col) = col.as_string_opt::<i64>() {
                 Ok(LayerCol::LargeUtf8 { col })
             } else if let Some(col) = col.as_string_view_opt() {
                 Ok(LayerCol::Utf8View { col })
diff --git a/raphtory/src/io/arrow/mod.rs b/raphtory/src/io/arrow/mod.rs
index cda0745ce4..30fe0a9fc2 100644
--- a/raphtory/src/io/arrow/mod.rs
+++ b/raphtory/src/io/arrow/mod.rs
@@ -1,15 +1,18 @@
 pub mod dataframe;
 pub mod df_loaders;
 mod layer_col;
-mod node_col;
-mod prop_handler;
+pub mod node_col;
+pub mod prop_handler;
 
 #[cfg(test)]
 mod test {
     use crate::{
         io::arrow::{
             dataframe::{DFChunk, DFView},
-            df_loaders::*,
+            df_loaders::{
+                edges::{load_edges_from_df_prefetch, ColumnNames},
+                nodes::load_nodes_from_df,
+            },
         },
         prelude::*,
     };
@@ -53,17 +56,18 @@ mod test {
         let graph = Graph::new();
         let layer_name: Option<&str> = None;
         let layer_col: Option<&str> = None;
-        load_edges_from_df(
+        let secondary_index: Option<&str> = None;
+
+        load_edges_from_df_prefetch(
             df,
-            "time",
-            "src",
-            "dst",
+            ColumnNames::new("time", secondary_index, "src", "dst", layer_col),
+            true,
             &["prop1", "prop2"],
             &[],
             None,
             layer_name,
-            layer_col,
             &graph,
+            false,
         )
         .expect("failed to load edges from pretend df");
 
@@ -148,10 +152,12 @@ mod test {
             num_rows: Some(2),
         };
         let graph = Graph::new();
+        let secondary_index: Option<&str> = None;
 
         load_nodes_from_df(
             df,
             "time",
+            secondary_index,
             "id",
             &["name"],
             &[],
@@ -159,6 +165,9 @@ mod test {
             Some("node_type"),
             None,
             &graph,
+            true,
+            None,
+            None,
         )
         .expect("failed to load nodes from pretend df");
 
diff --git a/raphtory/src/io/arrow/node_col.rs b/raphtory/src/io/arrow/node_col.rs
index 3a4c64ef56..419647bc47 100644
--- a/raphtory/src/io/arrow/node_col.rs
+++ b/raphtory/src/io/arrow/node_col.rs
@@ -1,3 +1,5 @@
+use std::any::Any;
+
 use crate::{errors::LoadError, io::arrow::dataframe::DFChunk, prelude::AdditionOps};
 use arrow::{
     array::{
@@ -6,8 +8,12 @@ use arrow::{
     },
     datatypes::{DataType, Int32Type, Int64Type, UInt32Type, UInt64Type},
 };
-use raphtory_api::core::entities::{GidRef, GidType};
+use raphtory_api::{
+    core::entities::{GidRef, GidType},
+    iter::IntoDynBoxed,
+};
 use rayon::prelude::{IndexedParallelIterator, *};
+use storage::utils::Iter4;
 
 trait NodeColOps: Send + Sync {
     fn has_missing_values(&self) -> bool {
@@ -20,6 +26,8 @@ trait NodeColOps: Send + Sync {
     fn null_count(&self) -> usize;
 
     fn len(&self) -> usize;
+
+    fn as_any(&self) -> &dyn Any;
 }
 
 impl NodeColOps for Int32Array {
@@ -36,6 +44,10 @@ impl NodeColOps for Int32Array {
     fn len(&self) -> usize {
         Array::len(self)
     }
+
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
 }
 
 impl NodeColOps for Int64Array {
@@ -52,6 +64,10 @@ impl NodeColOps for Int64Array {
     fn len(&self) -> usize {
         Array::len(self)
     }
+
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
 }
 
 impl NodeColOps for StringArray {
@@ -76,6 +92,10 @@ impl NodeColOps for StringArray {
     fn len(&self) -> usize {
         Array::len(self)
     }
+
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
 }
 
 impl NodeColOps for LargeStringArray {
@@ -101,6 +121,10 @@ impl NodeColOps for LargeStringArray {
     fn len(&self) -> usize {
         Array::len(self)
     }
+
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
 }
 
 impl NodeColOps for StringViewArray {
@@ -125,6 +149,10 @@ impl NodeColOps for StringViewArray {
     fn len(&self) -> usize {
         Array::len(self)
     }
+
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
 }
 
 impl NodeColOps for UInt32Array {
@@ -141,6 +169,10 @@ impl NodeColOps for UInt32Array {
     fn len(&self) -> usize {
         Array::len(self)
     }
+
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
 }
 
 impl NodeColOps for UInt64Array {
@@ -157,6 +189,10 @@ impl NodeColOps for UInt64Array {
     fn len(&self) -> usize {
         Array::len(self)
     }
+
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
 }
 
 pub struct NodeCol(Box<dyn NodeColOps>);
@@ -205,7 +241,39 @@ impl NodeCol {
     }
 
     pub fn iter(&self) -> impl Iterator<Item = GidRef<'_>> + '_ {
-        (0..self.0.len()).map(|i| self.0.get(i).unwrap())
+        if let Some(arr) = self.0.as_any().downcast_ref::<StringViewArray>() {
+            Iter4::I(arr.iter().filter_map(|item| Some(GidRef::Str(item?))))
+        } else if let Some(arr) = self.0.as_any().downcast_ref::<StringArray>() {
+            Iter4::J(arr.iter().filter_map(|item| Some(GidRef::Str(item?))))
+        } else if let Some(arr) = self.0.as_any().downcast_ref::<UInt64Array>() {
+            Iter4::K(arr.iter().filter_map(|item| Some(GidRef::U64(item?))))
+        } else if let Some(arr) = self.0.as_any().downcast_ref::<UInt32Array>() {
+            Iter4::L(
+                arr.iter()
+                    .filter_map(|item| Some(GidRef::U64(item? as u64)))
+                    .into_dyn_boxed(),
+            )
+        } else if let Some(arr) = self.0.as_any().downcast_ref::<Int32Array>() {
+            Iter4::L(
+                arr.iter()
+                    .filter_map(|item| Some(GidRef::U64(item? as u64)))
+                    .into_dyn_boxed(),
+            )
+        } else if let Some(arr) = self.0.as_any().downcast_ref::<LargeStringArray>() {
+            Iter4::L(
+                arr.iter()
+                    .filter_map(|item| Some(GidRef::Str(item?)))
+                    .into_dyn_boxed(),
+            )
+        } else if let Some(arr) = self.0.as_any().downcast_ref::<Int64Array>() {
+            Iter4::L(
+                arr.iter()
+                    .filter_map(|item| Some(GidRef::U64(item? as u64)))
+                    .into_dyn_boxed(),
+            )
+        } else {
+            unreachable!("Unsupported node column")
+        }
     }
 
     pub fn validate(
@@ -228,6 +296,14 @@ impl NodeCol {
     pub fn dtype(&self) -> GidType {
         self.0.dtype()
     }
+
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+
+    pub fn get(&self, i: usize) -> Option<GidRef<'_>> {
+        self.0.get(i)
+    }
 }
 
 pub fn lift_node_col(index: usize, df: &DFChunk) -> Result<NodeCol, LoadError> {
diff --git a/raphtory/src/io/arrow/prop_handler.rs b/raphtory/src/io/arrow/prop_handler.rs
index 9537fff3c2..7216ce7ff8 100644
--- a/raphtory/src/io/arrow/prop_handler.rs
+++ b/raphtory/src/io/arrow/prop_handler.rs
@@ -1,26 +1,14 @@
-use crate::{errors::GraphError, io::arrow::dataframe::DFChunk, prelude::Prop};
-use arrow::{
-    array::{
-        Array, ArrayRef, ArrowPrimitiveType, AsArray, BooleanArray, Decimal128Array,
-        FixedSizeListArray, GenericListArray, GenericStringArray, OffsetSizeTrait, PrimitiveArray,
-        StringViewArray, StructArray,
-    },
-    buffer::NullBuffer,
-    datatypes::{
-        DataType, Date32Type, Date64Type, Decimal128Type, Float32Type, Float64Type, Int32Type,
-        Int64Type, TimeUnit, TimestampMicrosecondType, TimestampMillisecondType,
-        TimestampNanosecondType, TimestampSecondType, UInt16Type, UInt32Type, UInt64Type,
-        UInt8Type,
-    },
-};
-use bigdecimal::BigDecimal;
-use chrono::{DateTime, Utc};
+use crate::{errors::GraphError, io::arrow::dataframe::DFChunk};
+use arrow::array::{Array, ArrayRef};
 use raphtory_api::core::{
-    entities::properties::prop::{data_type_as_prop_type, IntoPropList, PropType},
-    storage::{arc_str::ArcStr, dict_mapper::MaybeNew},
+    entities::properties::prop::{
+        data_type_as_prop_type,
+        prop_col::{lift_property_col, PropCol},
+        PropRef, PropType,
+    },
+    storage::dict_mapper::MaybeNew,
 };
 use rayon::prelude::*;
-use rustc_hash::FxHashMap;
 
 pub struct PropCols {
     prop_ids: Vec<usize>,
@@ -29,11 +17,11 @@ pub struct PropCols {
 }
 
 impl PropCols {
-    pub fn iter_row(&self, i: usize) -> impl Iterator<Item = (usize, Prop)> + '_ {
+    pub fn iter_row(&self, i: usize) -> impl Iterator<Item = (usize, PropRef<'_>)> + '_ {
         self.prop_ids
             .iter()
             .zip(self.cols.iter())
-            .filter_map(move |(id, col)| col.get(i).map(|v| (*id, v)))
+            .filter_map(move |(id, col)| col.get_ref(i).map(|v| (*id, v)))
     }
 
     pub fn len(&self) -> usize {
@@ -42,9 +30,18 @@ impl PropCols {
 
     pub fn par_rows(
         &self,
-    ) -> impl IndexedParallelIterator<Item = impl Iterator<Item = (usize, Prop)> + '_> + '_ {
+    ) -> impl IndexedParallelIterator<Item = impl Iterator<Item = (usize, PropRef<'_>)> + '_> + '_
+    {
         (0..self.len()).into_par_iter().map(|i| self.iter_row(i))
     }
+
+    pub fn prop_ids(&self) -> &[usize] {
+        &self.prop_ids
+    }
+
+    pub fn cols(&self) -> Vec<ArrayRef> {
+        self.cols.iter().map(|col| col.as_array()).collect()
+    }
 }
 
 pub fn combine_properties_arrow<E>(
@@ -58,8 +55,8 @@ where
 {
     let dtypes = indices
         .iter()
-        .map(|idx| data_type_as_prop_type(df.chunk[*idx].data_type()).map_err(Into::into))
-        .collect::<Result<Vec<_>, GraphError>>()?;
+        .map(|idx| data_type_as_prop_type(df.chunk[*idx].data_type()))
+        .collect::<Result<Vec<_>, _>>()?;
     let cols = indices
         .iter()
         .map(|idx| lift_property_col(&df.chunk[*idx]))
@@ -76,428 +73,3 @@ where
         len: df.len(),
     })
 }
-
-fn arr_as_prop(arr: ArrayRef) -> Prop {
-    match arr.data_type() {
-        DataType::Boolean => {
-            let arr = arr.as_boolean();
-            arr.iter().flatten().into_prop_list()
-        }
-        DataType::Int32 => {
-            let arr = arr.as_primitive::<Int32Type>();
-            arr.iter().flatten().into_prop_list()
-        }
-        DataType::Int64 => {
-            let arr = arr.as_primitive::<Int64Type>();
-            arr.iter().flatten().into_prop_list()
-        }
-        DataType::UInt8 => {
-            let arr = arr.as_primitive::<UInt8Type>();
-            arr.iter().flatten().into_prop_list()
-        }
-        DataType::UInt16 => {
-            let arr = arr.as_primitive::<UInt16Type>();
-            arr.iter().flatten().into_prop_list()
-        }
-        DataType::UInt32 => {
-            let arr = arr.as_primitive::<UInt32Type>();
-            arr.iter().flatten().into_prop_list()
-        }
-        DataType::UInt64 => {
-            let arr = arr.as_primitive::<UInt64Type>();
-            arr.iter().flatten().into_prop_list()
-        }
-        DataType::Float32 => {
-            let arr = arr.as_primitive::<Float32Type>();
-            arr.iter().flatten().into_prop_list()
-        }
-        DataType::Float64 => {
-            let arr = arr.as_primitive::<Float64Type>();
-            arr.iter().flatten().into_prop_list()
-        }
-        DataType::Utf8 => {
-            let arr = arr.as_string::<i32>();
-            arr.iter().flatten().into_prop_list()
-        }
-        DataType::LargeUtf8 => {
-            let arr = arr.as_string::<i64>();
-            arr.iter().flatten().into_prop_list()
-        }
-        DataType::Utf8View => {
-            let arr = arr.as_string_view();
-            arr.iter().flatten().into_prop_list()
-        }
-        DataType::List(_) => {
-            let arr = arr.as_list::<i32>();
-            arr.iter().flatten().map(arr_as_prop).into_prop_list()
-        }
-        DataType::FixedSizeList(_, _) => {
-            let arr = arr.as_fixed_size_list();
-            arr.iter().flatten().map(arr_as_prop).into_prop_list()
-        }
-        DataType::LargeList(_) => {
-            let arr = arr.as_list::<i64>();
-            arr.iter().flatten().map(arr_as_prop).into_prop_list()
-        }
-        DataType::Timestamp(TimeUnit::Second, tz) => {
-            let map_fn = if tz.is_some() {
-                |elem: i64| Prop::DTime(DateTime::<Utc>::from_timestamp_secs(elem).unwrap())
-            } else {
-                |elem: i64| Prop::NDTime(DateTime::from_timestamp_secs(elem).unwrap().naive_utc())
-            };
-            let arr = arr.as_primitive::<TimestampSecondType>();
-            arr.iter().flatten().map(map_fn).into_prop_list()
-        }
-        DataType::Timestamp(TimeUnit::Millisecond, tz) => {
-            let map_fn = if tz.is_some() {
-                |elem: i64| Prop::DTime(DateTime::<Utc>::from_timestamp_millis(elem).unwrap())
-            } else {
-                |elem: i64| Prop::NDTime(DateTime::from_timestamp_millis(elem).unwrap().naive_utc())
-            };
-            let arr = arr.as_primitive::<TimestampMillisecondType>();
-            arr.iter().flatten().map(map_fn).into_prop_list()
-        }
-        DataType::Timestamp(TimeUnit::Microsecond, tz) => {
-            let map_fn = if tz.is_some() {
-                |elem: i64| Prop::DTime(DateTime::<Utc>::from_timestamp_micros(elem).unwrap())
-            } else {
-                |elem: i64| Prop::NDTime(DateTime::from_timestamp_micros(elem).unwrap().naive_utc())
-            };
-            let arr = arr.as_primitive::<TimestampMicrosecondType>();
-            arr.iter().flatten().map(map_fn).into_prop_list()
-        }
-        DataType::Timestamp(TimeUnit::Nanosecond, tz) => {
-            let map_fn = if tz.is_some() {
-                |elem: i64| Prop::DTime(DateTime::<Utc>::from_timestamp_nanos(elem))
-            } else {
-                |elem: i64| Prop::NDTime(DateTime::from_timestamp_nanos(elem).naive_utc())
-            };
-            let arr = arr.as_primitive::<TimestampNanosecondType>();
-            arr.iter().flatten().map(map_fn).into_prop_list()
-        }
-        DataType::Date32 => {
-            let arr = arr.as_primitive::<Date32Type>();
-            arr.iter()
-                .flatten()
-                .map(|days| {
-                    let ms = (days as i64) * 86_400_000;
-                    Prop::NDTime(
-                        DateTime::from_timestamp_millis(ms)
-                            .expect("DateTime conversion failed for Date32 type")
-                            .naive_utc(),
-                    )
-                })
-                .into_prop_list()
-        }
-        DataType::Date64 => {
-            let arr = arr.as_primitive::<Date64Type>();
-            arr.iter()
-                .flatten()
-                .map(|ms| {
-                    Prop::NDTime(
-                        DateTime::from_timestamp_millis(ms)
-                            .expect("DateTime conversion failed for Date64 type")
-                            .naive_utc(),
-                    )
-                })
-                .into_prop_list()
-        }
-        DataType::Struct(_) => {
-            let arr = arr.as_struct();
-            let cols = arr
-                .columns()
-                .iter()
-                .map(|arr| lift_property_col(arr.as_ref()))
-                .collect::<Vec<_>>();
-
-            let mut props = Vec::with_capacity(arr.len());
-            for i in 0..arr.len() {
-                let fields = cols
-                    .iter()
-                    .zip(arr.fields())
-                    .filter_map(|(col, field)| {
-                        col.get(i)
-                            .map(|prop| (ArcStr::from(field.name().as_str()), prop))
-                    })
-                    .collect::<FxHashMap<_, _>>();
-                props.push(Prop::Map(fields.into()));
-            }
-
-            props.into_prop_list()
-        }
-        DataType::Decimal128(precision, scale) if *precision <= 38 => {
-            let arr = arr.as_primitive::<Decimal128Type>();
-            arr.iter()
-                .flatten()
-                .map(|elem| Prop::Decimal(BigDecimal::new(elem.into(), *scale as i64)))
-                .into_prop_list()
-        }
-        DataType::Null => Prop::List(vec![].into()),
-        dt => panic!("Data type not recognized {dt:?}"),
-    }
-}
-
-trait PropCol: Send + Sync {
-    fn get(&self, i: usize) -> Option<Prop>;
-}
-
-impl PropCol for BooleanArray {
-    fn get(&self, i: usize) -> Option<Prop> {
-        if self.is_null(i) || self.len() <= i {
-            None
-        } else {
-            Some(Prop::Bool(self.value(i)))
-        }
-    }
-}
-
-impl<T: ArrowPrimitiveType> PropCol for PrimitiveArray<T>
-where
-    T::Native: Into<Prop>,
-{
-    fn get(&self, i: usize) -> Option<Prop> {
-        if self.is_null(i) || self.len() <= i {
-            None
-        } else {
-            Some(self.value(i).into())
-        }
-    }
-}
-
-impl<I: OffsetSizeTrait> PropCol for GenericStringArray<I> {
-    fn get(&self, i: usize) -> Option<Prop> {
-        if self.is_null(i) || self.len() <= i {
-            None
-        } else {
-            Some(Prop::str(self.value(i)))
-        }
-    }
-}
-
-impl PropCol for StringViewArray {
-    fn get(&self, i: usize) -> Option<Prop> {
-        if self.is_null(i) || self.len() <= i {
-            None
-        } else {
-            Some(Prop::str(self.value(i)))
-        }
-    }
-}
-
-impl<I: OffsetSizeTrait> PropCol for GenericListArray<I> {
-    fn get(&self, i: usize) -> Option<Prop> {
-        if i >= self.len() || self.is_null(i) {
-            None
-        } else {
-            Some(arr_as_prop(self.value(i)))
-        }
-    }
-}
-
-impl PropCol for FixedSizeListArray {
-    fn get(&self, i: usize) -> Option<Prop> {
-        if i >= self.len() || self.is_null(i) {
-            None
-        } else {
-            Some(arr_as_prop(self.value(i)))
-        }
-    }
-}
-
-struct EmptyCol;
-
-impl PropCol for EmptyCol {
-    fn get(&self, _i: usize) -> Option<Prop> {
-        None
-    }
-}
-
-struct MapCol {
-    validity: Option<NullBuffer>,
-    values: Vec<(String, Box<dyn PropCol>)>,
-}
-
-impl MapCol {
-    fn new(arr: &StructArray) -> Self {
-        let validity = arr.nulls().cloned();
-        let values = arr
-            .fields()
-            .iter()
-            .zip(arr.columns())
-            .map(|(field, col)| (field.name().clone(), lift_property_col(col.as_ref())))
-            .collect();
-        Self { validity, values }
-    }
-}
-
-impl PropCol for MapCol {
-    fn get(&self, i: usize) -> Option<Prop> {
-        if self
-            .validity
-            .as_ref()
-            .is_none_or(|validity| validity.is_valid(i))
-        {
-            Some(Prop::map(self.values.iter().filter_map(|(field, col)| {
-                Some((field.as_str(), col.get(i)?))
-            })))
-        } else {
-            None
-        }
-    }
-}
-
-struct MappedPrimitiveCol<T: ArrowPrimitiveType> {
-    arr: PrimitiveArray<T>,
-    map: fn(T::Native) -> Prop,
-}
-
-impl<T: ArrowPrimitiveType> PropCol for MappedPrimitiveCol<T> {
-    fn get(&self, i: usize) -> Option<Prop> {
-        if i >= self.arr.len() || self.arr.is_null(i) {
-            None
-        } else {
-            Some((self.map)(self.arr.value(i)))
-        }
-    }
-}
-
-struct DecimalPropCol {
-    arr: Decimal128Array,
-    scale: i64,
-}
-
-impl PropCol for DecimalPropCol {
-    fn get(&self, i: usize) -> Option<Prop> {
-        if i >= self.arr.len() || self.arr.is_null(i) {
-            None
-        } else {
-            Some(Prop::Decimal(BigDecimal::new(
-                self.arr.value(i).into(),
-                self.scale,
-            )))
-        }
-    }
-}
-
-fn lift_property_col(arr: &dyn Array) -> Box<dyn PropCol> {
-    match arr.data_type() {
-        DataType::Boolean => Box::new(arr.as_boolean().clone()),
-        DataType::Int32 => Box::new(arr.as_primitive::<Int32Type>().clone()),
-        DataType::Int64 => Box::new(arr.as_primitive::<Int64Type>().clone()),
-        DataType::UInt8 => Box::new(arr.as_primitive::<UInt8Type>().clone()),
-        DataType::UInt16 => Box::new(arr.as_primitive::<UInt16Type>().clone()),
-        DataType::UInt32 => Box::new(arr.as_primitive::<UInt32Type>().clone()),
-        DataType::UInt64 => Box::new(arr.as_primitive::<UInt64Type>().clone()),
-        DataType::Float32 => Box::new(arr.as_primitive::<Float32Type>().clone()),
-        DataType::Float64 => Box::new(arr.as_primitive::<Float64Type>().clone()),
-        DataType::Utf8 => Box::new(arr.as_string::<i32>().clone()),
-        DataType::LargeUtf8 => Box::new(arr.as_string::<i64>().clone()),
-        DataType::Utf8View => Box::new(arr.as_string_view().clone()),
-        DataType::List(_) => Box::new(arr.as_list::<i32>().clone()),
-        DataType::LargeList(_) => Box::new(arr.as_list::<i64>().clone()),
-        DataType::FixedSizeList(_, _) => Box::new(arr.as_fixed_size_list().clone()),
-        DataType::Struct(_) => Box::new(MapCol::new(arr.as_struct())),
-        DataType::Timestamp(timeunit, timezone) => match timezone {
-            Some(_) => match timeunit {
-                TimeUnit::Second => Box::new(MappedPrimitiveCol {
-                    arr: arr.as_primitive::<TimestampSecondType>().clone(),
-                    map: |v| {
-                        Prop::DTime(
-                            DateTime::<Utc>::from_timestamp(v, 0)
-                                .expect("DateTime conversion failed"),
-                        )
-                    },
-                }),
-                TimeUnit::Millisecond => Box::new(MappedPrimitiveCol {
-                    arr: arr.as_primitive::<TimestampMillisecondType>().clone(),
-                    map: |v| {
-                        Prop::DTime(
-                            DateTime::<Utc>::from_timestamp_millis(v)
-                                .expect("DateTime conversion failed"),
-                        )
-                    },
-                }),
-                TimeUnit::Microsecond => Box::new(MappedPrimitiveCol {
-                    arr: arr.as_primitive::<TimestampMicrosecondType>().clone(),
-                    map: |v| {
-                        Prop::DTime(
-                            DateTime::<Utc>::from_timestamp_micros(v)
-                                .expect("DateTime conversion failed"),
-                        )
-                    },
-                }),
-                TimeUnit::Nanosecond => Box::new(MappedPrimitiveCol {
-                    arr: arr.as_primitive::<TimestampNanosecondType>().clone(),
-                    map: |v| Prop::DTime(DateTime::<Utc>::from_timestamp_nanos(v)),
-                }),
-            },
-            None => match timeunit {
-                TimeUnit::Second => Box::new(MappedPrimitiveCol {
-                    arr: arr.as_primitive::<TimestampSecondType>().clone(),
-                    map: |v| {
-                        Prop::NDTime(
-                            DateTime::from_timestamp(v, 0)
-                                .expect("DateTime conversion failed")
-                                .naive_utc(),
-                        )
-                    },
-                }),
-                TimeUnit::Millisecond => Box::new(MappedPrimitiveCol {
-                    arr: arr.as_primitive::<TimestampMillisecondType>().clone(),
-                    map: |v| {
-                        Prop::NDTime(
-                            DateTime::from_timestamp_millis(v)
-                                .expect("DateTime conversion failed")
-                                .naive_utc(),
-                        )
-                    },
-                }),
-                TimeUnit::Microsecond => Box::new(MappedPrimitiveCol {
-                    arr: arr.as_primitive::<TimestampMicrosecondType>().clone(),
-                    map: |v| {
-                        Prop::NDTime(
-                            DateTime::from_timestamp_micros(v)
-                                .expect("DateTime conversion failed")
-                                .naive_utc(),
-                        )
-                    },
-                }),
-                TimeUnit::Nanosecond => Box::new(MappedPrimitiveCol {
-                    arr: arr.as_primitive::<TimestampNanosecondType>().clone(),
-                    map: |v| Prop::NDTime(DateTime::from_timestamp_nanos(v).naive_utc()),
-                }),
-            },
-        },
-        DataType::Date32 => Box::new(MappedPrimitiveCol {
-            arr: arr.as_primitive::<Date32Type>().clone(),
-            map: |days| {
-                let ms = (days as i64) * 86_400_000; // convert days to ms
-                Prop::NDTime(
-                    DateTime::from_timestamp_millis(ms)
-                        .expect("DateTime conversion failed for Date32 type")
-                        .naive_utc(),
-                )
-            },
-        }),
-        DataType::Date64 => Box::new(MappedPrimitiveCol {
-            arr: arr.as_primitive::<Date64Type>().clone(),
-            map: |ms| {
-                Prop::NDTime(
-                    DateTime::from_timestamp_millis(ms)
-                        .expect("DateTime conversion failed for Date64 type")
-                        .naive_utc(),
-                )
-            },
-        }),
-        DataType::Decimal128(precision, scale) if *precision <= 38 => {
-            let arr = arr.as_primitive::<Decimal128Type>().clone();
-            Box::new(DecimalPropCol {
-                arr,
-                scale: *scale as i64,
-            })
-        }
-        DataType::Null => Box::new(EmptyCol),
-
-        unsupported => panic!("Data type not supported: {:?}", unsupported),
-    }
-}
diff --git a/raphtory/src/io/csv_loader.rs b/raphtory/src/io/csv_loader.rs
index 22547ed05a..d993ad816c 100644
--- a/raphtory/src/io/csv_loader.rs
+++ b/raphtory/src/io/csv_loader.rs
@@ -34,7 +34,7 @@
 //!              time,
 //!              src_id,
 //!              [("name", Prop::str("Character"))],
-//!              None,
+//!              None, None
 //!          )
 //!          .map_err(|err| error!("{:?}", err))
 //!          .ok();
@@ -42,7 +42,7 @@
 //!              time,
 //!              dst_id,
 //!              [("name", Prop::str("Character"))],
-//!              None,
+//!              None, None
 //!          )
 //!          .map_err(|err| error!("{:?}", err))
 //!          .ok();
@@ -523,10 +523,10 @@ mod csv_loader_test {
                 let dst_id = lotr.dst_id.id();
                 let time = lotr.time;
 
-                g.add_node(time, src_id, [("name", Prop::str("Character"))], None)
+                g.add_node(time, src_id, [("name", Prop::str("Character"))], None, None)
                     .map_err(|err| error!("{:?}", err))
                     .ok();
-                g.add_node(time, dst_id, [("name", Prop::str("Character"))], None)
+                g.add_node(time, dst_id, [("name", Prop::str("Character"))], None, None)
                     .map_err(|err| error!("{:?}", err))
                     .ok();
                 g.add_edge(
@@ -551,10 +551,10 @@ mod csv_loader_test {
                 let dst_id = lotr.get(1).map(|s| s.id()).unwrap();
                 let time = lotr.get(2).map(|s| s.parse::<i64>().unwrap()).unwrap();
 
-                g.add_node(time, src_id, [("name", Prop::str("Character"))], None)
+                g.add_node(time, src_id, [("name", Prop::str("Character"))], None, None)
                     .map_err(|err| error!("{:?}", err))
                     .ok();
-                g.add_node(time, dst_id, [("name", Prop::str("Character"))], None)
+                g.add_node(time, dst_id, [("name", Prop::str("Character"))], None, None)
                     .map_err(|err| error!("{:?}", err))
                     .ok();
                 g.add_edge(
diff --git a/raphtory/src/io/json_loader.rs b/raphtory/src/io/json_loader.rs
index 323d99f3bb..d91c6d9e3a 100644
--- a/raphtory/src/io/json_loader.rs
+++ b/raphtory/src/io/json_loader.rs
@@ -309,7 +309,7 @@ mod tests {
     fn test_json_rec(g: Graph, loader: JsonLinesLoader<TestRecord>) {
         loader
             .load_into_graph(&g, |testrec: TestRecord, g: &Graph| {
-                let _ = g.add_node(testrec.time, testrec.name.clone(), NO_PROPS, None);
+                let _ = g.add_node(testrec.time, testrec.name.clone(), NO_PROPS, None, None);
                 Ok(())
             })
             .expect("Unable to add node to graph");
diff --git a/raphtory/src/io/mod.rs b/raphtory/src/io/mod.rs
index 1fd56c86e8..e2e8290fa5 100644
--- a/raphtory/src/io/mod.rs
+++ b/raphtory/src/io/mod.rs
@@ -1,7 +1,17 @@
-#[cfg(feature = "arrow")]
+use std::sync::LazyLock;
+
+use rayon::{ThreadPool, ThreadPoolBuilder};
+
 pub mod arrow;
 pub mod csv_loader;
 pub mod json_loader;
 pub mod neo4j_loader;
-#[cfg(feature = "arrow")]
+
 pub mod parquet_loaders;
+
+static LOAD_POOL: LazyLock<ThreadPool> = LazyLock::new(|| {
+    ThreadPoolBuilder::new()
+        .thread_name(|idx| format!("PS Bulk Load Thread-{idx}"))
+        .build()
+        .unwrap()
+});
diff --git a/raphtory/src/io/neo4j_loader.rs b/raphtory/src/io/neo4j_loader.rs
index 5d2867532b..a4a6f1149b 100644
--- a/raphtory/src/io/neo4j_loader.rs
+++ b/raphtory/src/io/neo4j_loader.rs
@@ -63,12 +63,12 @@ mod neo_loader_test {
         let relation_type = relation.typ();
 
         graph
-            .add_node(actor_born, actor_name.clone(), NO_PROPS, None)
+            .add_node(actor_born, actor_name.clone(), NO_PROPS, None, None)
             .unwrap()
             .add_metadata([("type", "actor")])
             .unwrap();
         graph
-            .add_node(film_release, film_title.clone(), NO_PROPS, None)
+            .add_node(film_release, film_title.clone(), NO_PROPS, None, None)
             .unwrap()
             .add_metadata([
                 ("type", "film".into_prop()),
diff --git a/raphtory/src/io/parquet_loaders.rs b/raphtory/src/io/parquet_loaders.rs
index 0bd7b1e934..7c7b47a185 100644
--- a/raphtory/src/io/parquet_loaders.rs
+++ b/raphtory/src/io/parquet_loaders.rs
@@ -1,9 +1,15 @@
 use crate::{
     db::api::view::StaticGraphViewOps,
-    errors::{GraphError, InvalidPathReason::PathDoesNotExist},
-    io::arrow::{dataframe::*, df_loaders::*},
+    errors::GraphError,
+    io::arrow::{
+        dataframe::*,
+        df_loaders::{
+            edges::{load_edges_from_df_prefetch, ColumnNames},
+            nodes::{load_node_props_from_df, load_nodes_from_df},
+            *,
+        },
+    },
     prelude::{AdditionOps, DeletionOps, PropertyAdditionOps},
-    serialise::incremental::InternalCache,
 };
 use arrow::{
     array::{Array, RecordBatch, StructArray},
@@ -12,8 +18,6 @@ use arrow::{
     error::ArrowError,
 };
 use parquet::arrow::{arrow_reader::ParquetRecordBatchReaderBuilder, ProjectionMask};
-#[cfg(feature = "storage")]
-use pometry_storage::RAError;
 use raphtory_api::core::entities::properties::prop::{arrow_dtype_from_prop_type, Prop, PropType};
 use std::{
     collections::HashMap,
@@ -38,27 +42,41 @@ pub(crate) fn is_parquet_path(path: &PathBuf) -> Result<bool, std::io::Error> {
 }
 
 pub fn load_nodes_from_parquet<
-    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps + InternalCache,
+    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps + std::fmt::Debug,
 >(
     graph: &G,
     parquet_path: &Path,
     time: &str,
+    secondary_index: Option<&str>,
     id: &str,
     node_type: Option<&str>,
     node_type_col: Option<&str>,
     properties: &[&str],
     metadata: &[&str],
     shared_metadata: Option<&HashMap<String, Prop>>,
+    layer: Option<&str>,
+    layer_col: Option<&str>,
     batch_size: Option<usize>,
+    resolve_nodes: bool,
     schema: Option<Arc<HashMap<String, PropType>>>,
 ) -> Result<(), GraphError> {
     let mut cols_to_check = vec![id, time];
+
     cols_to_check.extend_from_slice(properties);
     cols_to_check.extend_from_slice(metadata);
+
     if let Some(ref node_type_col) = node_type_col {
         cols_to_check.push(node_type_col.as_ref());
     }
 
+    if let Some(ref secondary_index) = secondary_index {
+        cols_to_check.push(secondary_index.as_ref());
+    }
+
+    if let Some(ref layer_col) = layer_col {
+        cols_to_check.push(layer_col.as_ref());
+    }
+
     for path in get_parquet_file_paths(parquet_path)? {
         let df_view = process_parquet_file_to_df(
             path.as_path(),
@@ -70,6 +88,7 @@ pub fn load_nodes_from_parquet<
         load_nodes_from_df(
             df_view,
             time,
+            secondary_index,
             id,
             properties,
             metadata,
@@ -77,37 +96,53 @@ pub fn load_nodes_from_parquet<
             node_type,
             node_type_col,
             graph,
-        )
-        .map_err(|e| GraphError::LoadFailure(e.to_string()))?;
+            resolve_nodes,
+            layer,
+            layer_col,
+        )?;
     }
 
     Ok(())
 }
 
-pub fn load_edges_from_parquet<
-    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps + InternalCache,
->(
+pub fn load_edges_from_parquet<G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps>(
     graph: &G,
     parquet_path: impl AsRef<Path>,
-    time: &str,
-    src: &str,
-    dst: &str,
+    column_names: ColumnNames,
+    resolve_nodes: bool,
     properties: &[&str],
     metadata: &[&str],
     shared_metadata: Option<&HashMap<String, Prop>>,
     layer: Option<&str>,
-    layer_col: Option<&str>,
     batch_size: Option<usize>,
     schema: Option<Arc<HashMap<String, PropType>>>,
 ) -> Result<(), GraphError> {
+    let ColumnNames {
+        time,
+        secondary_index,
+        src,
+        dst,
+        layer_col,
+        layer_id_col,
+        edge_id,
+    } = column_names;
+
     let parquet_path = parquet_path.as_ref();
-    let mut cols_to_check = vec![src, dst, time];
+    let mut cols_to_check = [src, dst, time]
+        .into_iter()
+        .chain(layer_id_col)
+        .chain(edge_id)
+        .collect::<Vec<_>>();
+
     cols_to_check.extend_from_slice(properties);
     cols_to_check.extend_from_slice(metadata);
 
     if let Some(ref layer_col) = layer_col {
         cols_to_check.push(layer_col.as_ref());
     }
+    if let Some(ref secondary_index) = secondary_index {
+        cols_to_check.push(secondary_index.as_ref());
+    }
 
     let all_files = get_parquet_file_paths(parquet_path)?
         .into_iter()
@@ -150,42 +185,43 @@ pub fn load_edges_from_parquet<
         num_rows: Some(count_rows),
     };
 
-    load_edges_from_df(
+    load_edges_from_df_prefetch(
         df_view,
-        time,
-        src,
-        dst,
+        column_names,
+        resolve_nodes,
         properties,
         metadata,
         shared_metadata,
         layer,
-        layer_col,
         graph,
-    )
-    .map_err(|e| GraphError::LoadFailure(e.to_string()))?;
+        false,
+    )?;
 
     Ok(())
 }
 
 pub fn load_node_metadata_from_parquet<
-    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps + InternalCache,
+    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps + std::fmt::Debug,
 >(
     graph: &G,
     parquet_path: &Path,
     id: &str,
     node_type: Option<&str>,
     node_type_col: Option<&str>,
+    node_id_col: Option<&str>,      // for inner parquet use only
+    node_type_id_col: Option<&str>, // for inner parquet use only
     metadata_properties: &[&str],
     shared_metadata: Option<&HashMap<String, Prop>>,
     batch_size: Option<usize>,
     schema: Option<Arc<HashMap<String, PropType>>>,
 ) -> Result<(), GraphError> {
-    let mut cols_to_check = vec![id];
-    cols_to_check.extend_from_slice(metadata_properties);
+    let mut cols_to_check = std::iter::once(id)
+        .chain(node_type_id_col)
+        .chain(node_type_col)
+        .chain(node_id_col)
+        .collect::<Vec<_>>();
 
-    if let Some(ref node_type_col) = node_type_col {
-        cols_to_check.push(node_type_col.as_ref());
-    }
+    cols_to_check.extend_from_slice(metadata_properties);
 
     for path in get_parquet_file_paths(parquet_path)? {
         let df_view = process_parquet_file_to_df(
@@ -201,18 +237,19 @@ pub fn load_node_metadata_from_parquet<
             id,
             node_type,
             node_type_col,
+            node_id_col,
+            node_type_id_col,
             metadata_properties,
             shared_metadata,
             graph,
-        )
-        .map_err(|e| GraphError::LoadFailure(e.to_string()))?;
+        )?;
     }
 
     Ok(())
 }
 
 pub fn load_edge_metadata_from_parquet<
-    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps + InternalCache,
+    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps,
 >(
     graph: &G,
     parquet_path: &Path,
@@ -224,6 +261,7 @@ pub fn load_edge_metadata_from_parquet<
     layer_col: Option<&str>,
     batch_size: Option<usize>,
     schema: Option<Arc<HashMap<String, PropType>>>,
+    resolve_nodes: bool,
 ) -> Result<(), GraphError> {
     let mut cols_to_check = vec![src, dst];
     if let Some(ref layer_col) = layer_col {
@@ -240,7 +278,7 @@ pub fn load_edge_metadata_from_parquet<
             schema.clone(),
         )?;
         df_view.check_cols_exist(&cols_to_check)?;
-        load_edges_props_from_df(
+        load_edges_props_from_df_prefetch(
             df_view,
             src,
             dst,
@@ -249,8 +287,8 @@ pub fn load_edge_metadata_from_parquet<
             layer,
             layer_col,
             graph,
-        )
-        .map_err(|e| GraphError::LoadFailure(e.to_string()))?;
+            resolve_nodes,
+        )?;
     }
 
     Ok(())
@@ -261,18 +299,28 @@ pub fn load_edge_deletions_from_parquet<
 >(
     graph: &G,
     parquet_path: &Path,
-    time: &str,
-    src: &str,
-    dst: &str,
+    column_names: ColumnNames,
     layer: Option<&str>,
-    layer_col: Option<&str>,
+    resolve_nodes: bool,
     batch_size: Option<usize>,
     schema: Option<Arc<HashMap<String, PropType>>>,
 ) -> Result<(), GraphError> {
-    let mut cols_to_check = vec![src, dst, time];
-    if let Some(ref layer_col) = layer_col {
-        cols_to_check.push(layer_col.as_ref());
-    }
+    let ColumnNames {
+        time,
+        secondary_index,
+        src,
+        dst,
+        edge_id,
+        layer_col,
+        layer_id_col,
+    } = column_names;
+    let cols_to_check = vec![src, dst, time]
+        .into_iter()
+        .chain(secondary_index)
+        .chain(layer_col)
+        .chain(layer_id_col)
+        .chain(edge_id)
+        .collect::<Vec<_>>();
 
     for path in get_parquet_file_paths(parquet_path)? {
         let df_view = process_parquet_file_to_df(
@@ -282,8 +330,7 @@ pub fn load_edge_deletions_from_parquet<
             schema.clone(),
         )?;
         df_view.check_cols_exist(&cols_to_check)?;
-        load_edge_deletions_from_df(df_view, time, src, dst, layer, layer_col, graph)
-            .map_err(|e| GraphError::LoadFailure(e.to_string()))?;
+        load_edge_deletions_from_df_prefetch(df_view, column_names, resolve_nodes, layer, graph)?;
     }
     Ok(())
 }
@@ -292,15 +339,21 @@ pub fn load_graph_props_from_parquet<G: StaticGraphViewOps + PropertyAdditionOps
     graph: &G,
     parquet_path: &Path,
     time: &str,
+    secondary_index: Option<&str>,
     properties: &[&str],
     metadata: &[&str],
     batch_size: Option<usize>,
     schema: Option<Arc<HashMap<String, PropType>>>,
 ) -> Result<(), GraphError> {
     let mut cols_to_check = vec![time];
+
     cols_to_check.extend_from_slice(properties);
     cols_to_check.extend_from_slice(metadata);
 
+    if let Some(ref secondary_index) = secondary_index {
+        cols_to_check.push(secondary_index.as_ref());
+    }
+
     for path in get_parquet_file_paths(parquet_path)? {
         let df_view = process_parquet_file_to_df(
             path.as_path(),
@@ -309,8 +362,14 @@ pub fn load_graph_props_from_parquet<G: StaticGraphViewOps + PropertyAdditionOps
             schema.clone(),
         )?;
         df_view.check_cols_exist(&cols_to_check)?;
-        load_graph_props_from_df(df_view, time, Some(properties), Some(metadata), graph)
-            .map_err(|e| GraphError::LoadFailure(e.to_string()))?;
+        load_graph_props_from_df(
+            df_view,
+            time,
+            secondary_index,
+            Some(properties),
+            Some(metadata),
+            graph,
+        )?;
     }
 
     Ok(())
@@ -321,7 +380,7 @@ pub(crate) fn process_parquet_file_to_df(
     col_names: Option<&[&str]>,
     batch_size: Option<usize>,
     schema: Option<Arc<HashMap<String, PropType>>>,
-) -> Result<DFView<impl Iterator<Item = Result<DFChunk, GraphError>>>, GraphError> {
+) -> Result<DFView<impl Iterator<Item = Result<DFChunk, GraphError>> + Send>, GraphError> {
     let (names, chunks, num_rows) = read_parquet_file(parquet_file_path, col_names)?;
 
     let names: Vec<String> = names
@@ -330,11 +389,11 @@ pub(crate) fn process_parquet_file_to_df(
         .collect();
 
     let chunks = match batch_size {
-        None => chunks,
+        None => chunks.with_batch_size(500_000),
         Some(batch_size) => chunks.with_batch_size(batch_size),
     };
 
-    let chunks = chunks.build()?.into_iter().map(move |result| match result {
+    let chunks = chunks.build()?.map(move |result| match result {
         Ok(r) => {
             let casted_batch = if let Some(schema) = schema.as_deref() {
                 cast_columns(r, schema)?
@@ -391,9 +450,7 @@ pub fn get_parquet_file_paths(parquet_path: &Path) -> Result<Vec<PathBuf>, Graph
             }
         }
     } else {
-        return Err(GraphError::from(PathDoesNotExist(
-            parquet_path.to_path_buf(),
-        )));
+        return Err(GraphError::PathDoesNotExist(parquet_path.to_path_buf()));
     }
     parquet_files.sort();
 
@@ -402,7 +459,7 @@ pub fn get_parquet_file_paths(parquet_path: &Path) -> Result<Vec<PathBuf>, Graph
 
 fn cast_type(old_type: &DataType, target_type: &PropType) -> Result<DataType, GraphError> {
     let casted = match target_type {
-        PropType::List(inner) | PropType::Array(inner) => match old_type {
+        PropType::List(inner) => match old_type {
             DataType::List(old_inner) => {
                 let casted_inner_dtype = cast_type(old_inner.data_type(), inner)?;
                 DataType::List(FieldRef::new(
@@ -506,28 +563,6 @@ pub(crate) fn cast_columns(
     Ok(RecordBatch::from(casted_struct))
 }
 
-#[cfg(feature = "storage")]
-pub fn read_struct_arrays(
-    path: &Path,
-    col_names: Option<&[&str]>,
-) -> Result<impl Iterator<Item = Result<StructArray, RAError>>, GraphError> {
-    let readers = get_parquet_file_paths(path)?
-        .into_iter()
-        .map(|path| {
-            read_parquet_file(path, col_names)
-                .and_then(|(_, reader, _)| Ok::<_, GraphError>(reader.build()?))
-        })
-        .collect::<Result<Vec<_>, _>>()?;
-
-    let chunks = readers.into_iter().flat_map(|iter| {
-        iter.map(move |cols| {
-            cols.map(|col| StructArray::from(col))
-                .map_err(RAError::ArrowRs)
-        })
-    });
-    Ok(chunks)
-}
-
 #[cfg(test)]
 mod test {
     use super::*;
diff --git a/raphtory/src/lib.rs b/raphtory/src/lib.rs
index 9df3347e1a..73338ee569 100644
--- a/raphtory/src/lib.rs
+++ b/raphtory/src/lib.rs
@@ -37,7 +37,8 @@
 //!   1,
 //!   "Gandalf",
 //!   [("type", Prop::str("Character"))],
-//!   None
+//!   None,
+//!   None,
 //! ).unwrap();
 //!
 //! graph.add_node(
@@ -45,6 +46,7 @@
 //!   "Frodo",
 //!   [("type", Prop::str("Character"))],
 //!   None,
+//!   None,
 //! ).unwrap();
 //!
 //! graph.add_edge(
@@ -106,7 +108,7 @@ pub mod io;
 pub mod api;
 pub mod core;
 pub mod errors;
-#[cfg(feature = "proto")]
+#[cfg(feature = "io")]
 pub mod serialise;
 pub mod storage;
 
@@ -141,7 +143,7 @@ pub mod prelude {
                 },
                 view::{EdgeViewOps, GraphViewOps, LayerOps, NodeViewOps, TimeOps},
             },
-            graph::graph::Graph,
+            graph::{graph::Graph, views::deletion_graph::PersistentGraph},
         },
     };
 
@@ -151,16 +153,12 @@ pub mod prelude {
 
     pub use crate::db::graph::views::filter::model::{node_filter::NodeFilter, EdgeFilter};
 
-    #[cfg(feature = "storage")]
-    pub use {
-        crate::db::api::storage::graph::storage_ops::disk_storage::IntoGraph,
-        raphtory_storage::disk::{DiskGraphStorage, ParquetLayerCols},
-    };
+    pub use storage::{persist::config::ConfigOps, Config};
 
-    #[cfg(feature = "proto")]
+    #[cfg(feature = "io")]
     pub use crate::serialise::{
         parquet::{ParquetDecoder, ParquetEncoder},
-        CacheOps, StableDecode, StableEncode,
+        StableDecode, StableEncode,
     };
 
     #[cfg(feature = "search")]
diff --git a/raphtory/src/python/algorithm/epidemics.rs b/raphtory/src/python/algorithm/epidemics.rs
index ec2db5a56b..75807b0813 100644
--- a/raphtory/src/python/algorithm/epidemics.rs
+++ b/raphtory/src/python/algorithm/epidemics.rs
@@ -75,9 +75,10 @@ impl<'py> IntoPyObject<'py> for Infected {
     }
 }
 
-impl<'py> FromPyObject<'py> for Infected {
-    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
-        let res = ob.downcast::<PyInfected>()?;
+impl<'py> FromPyObject<'_, 'py> for Infected {
+    type Error = PyErr;
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
+        let res = ob.cast::<PyInfected>()?;
         Ok(res.get().inner)
     }
 }
@@ -88,8 +89,9 @@ pub enum PySeed {
     Probability(f64),
 }
 
-impl<'source> FromPyObject<'source> for PySeed {
-    fn extract_bound(ob: &Bound<'source, PyAny>) -> PyResult<Self> {
+impl<'py> FromPyObject<'_, 'py> for PySeed {
+    type Error = PyErr;
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
         let res = if ob.is_instance_of::<PyInt>() {
             Self::Number(ob.extract()?)
         } else if ob.is_instance_of::<PyFloat>() {
diff --git a/raphtory/src/python/config.rs b/raphtory/src/python/config.rs
new file mode 100644
index 0000000000..e3dc702fa3
--- /dev/null
+++ b/raphtory/src/python/config.rs
@@ -0,0 +1,14 @@
+use pyo3::{Borrowed, BoundObject, FromPyObject, PyAny};
+use pythonize::{depythonize, PythonizeError};
+use storage::Config;
+
+pub struct PyConfig(pub Config);
+
+impl<'a, 'py> FromPyObject<'a, 'py> for PyConfig {
+    type Error = PythonizeError;
+
+    fn extract(obj: Borrowed<'a, 'py, PyAny>) -> Result<Self, Self::Error> {
+        let config: Config = depythonize(&obj.into_bound())?;
+        Ok(PyConfig(config))
+    }
+}
diff --git a/raphtory/src/python/filter/edge_filter_builders.rs b/raphtory/src/python/filter/edge_filter_builders.rs
index b8fd412264..e4184e33e6 100644
--- a/raphtory/src/python/filter/edge_filter_builders.rs
+++ b/raphtory/src/python/filter/edge_filter_builders.rs
@@ -242,7 +242,7 @@ impl PyEdgeEndpoint {
     /// Selects the endpoint node ID field for filtering.
     ///
     /// Returns:
-    ///     filter.EdgeEndpointIdFilter
+    ///     filter.EdgeEndpointIdFilter:
     fn id(&self) -> PyEdgeEndpointIdFilterBuilder {
         PyEdgeEndpointIdFilterBuilder(self.0.id())
     }
@@ -250,7 +250,7 @@ impl PyEdgeEndpoint {
     /// Selects the endpoint node name field for filtering.
     ///
     /// Returns:
-    ///     filter.EdgeEndpointNameFilter
+    ///     filter.EdgeEndpointNameFilter:
     fn name(&self) -> PyEdgeEndpointNameFilterBuilder {
         PyEdgeEndpointNameFilterBuilder(self.0.name())
     }
@@ -258,7 +258,7 @@ impl PyEdgeEndpoint {
     /// Selects the endpoint node type field for filtering.
     ///
     /// Returns:
-    ///     filter.EdgeEndpointTypeFilter
+    ///     filter.EdgeEndpointTypeFilter:
     fn node_type(&self) -> PyEdgeEndpointTypeFilterBuilder {
         PyEdgeEndpointTypeFilterBuilder(self.0.node_type())
     }
@@ -271,7 +271,7 @@ impl PyEdgeEndpoint {
     ///     name (str): Property key.
     ///
     /// Returns:
-    ///     filter.PropertyFilterOps
+    ///     filter.PropertyFilterOps:
     fn property<'py>(
         &self,
         py: Python<'py>,
@@ -289,7 +289,7 @@ impl PyEdgeEndpoint {
     ///     name (str): Metadata key.
     ///
     /// Returns:
-    ///     filter.FilterOps
+    ///     filter.FilterOps:
     fn metadata<'py>(
         &self,
         py: Python<'py>,
@@ -322,7 +322,7 @@ impl PyEdgeFilter {
     /// Selects the edge **source endpoint** for filtering.
     ///
     /// Returns:
-    ///     filter.EdgeEndpoint
+    ///     filter.EdgeEndpoint:
     #[staticmethod]
     fn src() -> PyEdgeEndpoint {
         PyEdgeEndpoint(EdgeFilter::src())
@@ -331,7 +331,7 @@ impl PyEdgeFilter {
     /// Selects the edge **destination endpoint** for filtering.
     ///
     /// Returns:
-    ///     filter.EdgeEndpoint
+    ///     filter.EdgeEndpoint:
     #[staticmethod]
     fn dst() -> PyEdgeEndpoint {
         PyEdgeEndpoint(EdgeFilter::dst())
@@ -345,7 +345,7 @@ impl PyEdgeFilter {
     ///     name (str): Property key.
     ///
     /// Returns:
-    ///     filter.PropertyFilterOps
+    ///     filter.PropertyFilterOps:
     #[staticmethod]
     fn property<'py>(
         py: Python<'py>,
@@ -364,7 +364,7 @@ impl PyEdgeFilter {
     ///     name (str): Metadata key.
     ///
     /// Returns:
-    ///     filter.FilterOps
+    ///     filter.FilterOps:
     #[staticmethod]
     fn metadata<'py>(py: Python<'py>, name: String) -> PyResult<Bound<'py, PyPropertyExprBuilder>> {
         let b: MetadataFilterBuilder<EdgeFilter> =
@@ -381,7 +381,7 @@ impl PyEdgeFilter {
     ///     end (int): End time.
     ///
     /// Returns:
-    ///     filter.EdgeViewPropsFilterBuilder
+    ///     filter.EdgeViewPropsFilterBuilder:
     #[staticmethod]
     fn window(start: EventTime, end: EventTime) -> PyEdgeViewPropsFilterBuilder {
         PyEdgeViewPropsFilterBuilder(Arc::new(EdgeFilter.window(start, end)))
@@ -393,7 +393,7 @@ impl PyEdgeFilter {
     ///     time (int): Event time.
     ///
     /// Returns:
-    ///     filter.EdgeViewPropsFilterBuilder
+    ///     filter.EdgeViewPropsFilterBuilder:
     #[staticmethod]
     fn at(time: EventTime) -> PyEdgeViewPropsFilterBuilder {
         PyEdgeViewPropsFilterBuilder(Arc::new(EdgeFilter.at(time)))
@@ -405,7 +405,7 @@ impl PyEdgeFilter {
     ///     time (int): Lower time bound.
     ///
     /// Returns:
-    ///     filter.EdgeViewPropsFilterBuilder
+    ///     filter.EdgeViewPropsFilterBuilder:
     #[staticmethod]
     fn after(time: EventTime) -> PyEdgeViewPropsFilterBuilder {
         PyEdgeViewPropsFilterBuilder(Arc::new(EdgeFilter.after(time)))
@@ -417,7 +417,7 @@ impl PyEdgeFilter {
     ///     time (int): Upper time bound.
     ///
     /// Returns:
-    ///     filter.EdgeViewPropsFilterBuilder
+    ///     filter.EdgeViewPropsFilterBuilder:
     #[staticmethod]
     fn before(time: EventTime) -> PyEdgeViewPropsFilterBuilder {
         PyEdgeViewPropsFilterBuilder(Arc::new(EdgeFilter.before(time)))
@@ -426,7 +426,7 @@ impl PyEdgeFilter {
     /// Evaluates edge predicates against the latest available edge state.
     ///
     /// Returns:
-    ///     filter.EdgeViewPropsFilterBuilder
+    ///     filter.EdgeViewPropsFilterBuilder:
     #[staticmethod]
     fn latest() -> PyEdgeViewPropsFilterBuilder {
         PyEdgeViewPropsFilterBuilder(Arc::new(EdgeFilter.latest()))
@@ -438,7 +438,7 @@ impl PyEdgeFilter {
     ///     time (int): Snapshot time.
     ///
     /// Returns:
-    ///     filter.EdgeViewPropsFilterBuilder
+    ///     filter.EdgeViewPropsFilterBuilder:
     #[staticmethod]
     fn snapshot_at(time: EventTime) -> PyEdgeViewPropsFilterBuilder {
         PyEdgeViewPropsFilterBuilder(Arc::new(EdgeFilter.snapshot_at(time)))
@@ -447,7 +447,7 @@ impl PyEdgeFilter {
     /// Evaluates edge predicates against the most recent snapshot of the graph.
     ///
     /// Returns:
-    ///     filter.EdgeViewPropsFilterBuilder
+    ///     filter.EdgeViewPropsFilterBuilder:
     #[staticmethod]
     fn snapshot_latest() -> PyEdgeViewPropsFilterBuilder {
         PyEdgeViewPropsFilterBuilder(Arc::new(EdgeFilter.snapshot_latest()))
@@ -459,7 +459,7 @@ impl PyEdgeFilter {
     ///     layer (str): Layer name.
     ///
     /// Returns:
-    ///     filter.EdgeViewPropsFilterBuilder
+    ///     filter.EdgeViewPropsFilterBuilder:
     #[staticmethod]
     fn layer(layer: String) -> PyEdgeViewPropsFilterBuilder {
         PyEdgeViewPropsFilterBuilder(Arc::new(EdgeFilter.layer(layer)))
@@ -471,7 +471,7 @@ impl PyEdgeFilter {
     ///     layers (list[str]): Layer names.
     ///
     /// Returns:
-    ///     filter.EdgeViewPropsFilterBuilder
+    ///     filter.EdgeViewPropsFilterBuilder:
     #[staticmethod]
     fn layers(layers: FromIterable<String>) -> PyEdgeViewPropsFilterBuilder {
         PyEdgeViewPropsFilterBuilder(Arc::new(EdgeFilter.layer(layers)))
@@ -480,7 +480,7 @@ impl PyEdgeFilter {
     /// Matches edges that have at least one event in the current view.
     ///
     /// Returns:
-    ///     filter.FilterExpr
+    ///     filter.FilterExpr:
     #[staticmethod]
     fn is_active() -> PyFilterExpr {
         PyFilterExpr(Arc::new(EdgeFilter.is_active()))
@@ -489,7 +489,7 @@ impl PyEdgeFilter {
     /// Matches edges that are structurally valid in the current view.
     ///
     /// Returns:
-    ///     filter.FilterExpr
+    ///     filter.FilterExpr:
     #[staticmethod]
     fn is_valid() -> PyFilterExpr {
         PyFilterExpr(Arc::new(EdgeFilter.is_valid()))
@@ -498,7 +498,7 @@ impl PyEdgeFilter {
     /// Matches edges that have been deleted.
     ///
     /// Returns:
-    ///     filter.FilterExpr
+    ///     filter.FilterExpr:
     #[staticmethod]
     fn is_deleted() -> PyFilterExpr {
         PyFilterExpr(Arc::new(EdgeFilter.is_deleted()))
@@ -507,7 +507,7 @@ impl PyEdgeFilter {
     /// Matches edges that are self-loops (source == destination).
     ///
     /// Returns:
-    ///     filter.FilterExpr
+    ///     filter.FilterExpr:
     #[staticmethod]
     fn is_self_loop() -> PyFilterExpr {
         PyFilterExpr(Arc::new(EdgeFilter.is_self_loop()))
diff --git a/raphtory/src/python/filter/exploded_edge_filter_builder.rs b/raphtory/src/python/filter/exploded_edge_filter_builder.rs
index cfc860833d..62630c1931 100644
--- a/raphtory/src/python/filter/exploded_edge_filter_builder.rs
+++ b/raphtory/src/python/filter/exploded_edge_filter_builder.rs
@@ -47,7 +47,7 @@ impl PyExplodedEdgeFilter {
     ///     name (str): Property key.
     ///
     /// Returns:
-    ///     filter.PropertyFilterOps
+    ///     filter.PropertyFilterOps:
     #[staticmethod]
     fn property<'py>(
         py: Python<'py>,
@@ -66,7 +66,7 @@ impl PyExplodedEdgeFilter {
     ///     name (str): Metadata key.
     ///
     /// Returns:
-    ///     filter.FilterOps
+    ///     filter.FilterOps:
     #[staticmethod]
     fn metadata<'py>(py: Python<'py>, name: String) -> PyResult<Bound<'py, PyPropertyExprBuilder>> {
         let b: MetadataFilterBuilder<ExplodedEdgeFilter> =
@@ -83,7 +83,7 @@ impl PyExplodedEdgeFilter {
     ///     end (int): End time.
     ///
     /// Returns:
-    ///     filter.EdgeViewPropsFilterBuilder
+    ///     filter.EdgeViewPropsFilterBuilder:
     #[staticmethod]
     fn window(start: EventTime, end: EventTime) -> PyEdgeViewPropsFilterBuilder {
         PyEdgeViewPropsFilterBuilder(Arc::new(ExplodedEdgeFilter.window(start, end)))
@@ -95,7 +95,7 @@ impl PyExplodedEdgeFilter {
     ///     time (int): Event time.
     ///
     /// Returns:
-    ///     filter.EdgeViewPropsFilterBuilder
+    ///     filter.EdgeViewPropsFilterBuilder:
     #[staticmethod]
     fn at(time: EventTime) -> PyEdgeViewPropsFilterBuilder {
         PyEdgeViewPropsFilterBuilder(Arc::new(ExplodedEdgeFilter.at(time)))
@@ -107,7 +107,7 @@ impl PyExplodedEdgeFilter {
     ///     time (int): Lower time bound.
     ///
     /// Returns:
-    ///     filter.EdgeViewPropsFilterBuilder
+    ///     filter.EdgeViewPropsFilterBuilder:
     #[staticmethod]
     fn after(time: EventTime) -> PyEdgeViewPropsFilterBuilder {
         PyEdgeViewPropsFilterBuilder(Arc::new(ExplodedEdgeFilter.after(time)))
@@ -119,7 +119,7 @@ impl PyExplodedEdgeFilter {
     ///     time (int): Upper time bound.
     ///
     /// Returns:
-    ///     filter.EdgeViewPropsFilterBuilder
+    ///     filter.EdgeViewPropsFilterBuilder:
     #[staticmethod]
     fn before(time: EventTime) -> PyEdgeViewPropsFilterBuilder {
         PyEdgeViewPropsFilterBuilder(Arc::new(ExplodedEdgeFilter.before(time)))
@@ -128,7 +128,7 @@ impl PyExplodedEdgeFilter {
     /// Evaluates exploded edge predicates against the latest available state.
     ///
     /// Returns:
-    ///     filter.EdgeViewPropsFilterBuilder
+    ///     filter.EdgeViewPropsFilterBuilder:
     #[staticmethod]
     fn latest() -> PyEdgeViewPropsFilterBuilder {
         PyEdgeViewPropsFilterBuilder(Arc::new(ExplodedEdgeFilter.latest()))
@@ -140,7 +140,7 @@ impl PyExplodedEdgeFilter {
     ///     time (int): Snapshot time.
     ///
     /// Returns:
-    ///     filter.EdgeViewPropsFilterBuilder
+    ///     filter.EdgeViewPropsFilterBuilder:
     #[staticmethod]
     fn snapshot_at(time: EventTime) -> PyEdgeViewPropsFilterBuilder {
         PyEdgeViewPropsFilterBuilder(Arc::new(ExplodedEdgeFilter.snapshot_at(time)))
@@ -149,7 +149,7 @@ impl PyExplodedEdgeFilter {
     /// Evaluates exploded edge predicates against the most recent snapshot of the graph.
     ///
     /// Returns:
-    ///     filter.EdgeViewPropsFilterBuilder
+    ///     filter.EdgeViewPropsFilterBuilder:
     #[staticmethod]
     fn snapshot_latest() -> PyEdgeViewPropsFilterBuilder {
         PyEdgeViewPropsFilterBuilder(Arc::new(ExplodedEdgeFilter.snapshot_latest()))
@@ -161,7 +161,7 @@ impl PyExplodedEdgeFilter {
     ///     layer (str): Layer name.
     ///
     /// Returns:
-    ///     filter.EdgeViewPropsFilterBuilder
+    ///     filter.EdgeViewPropsFilterBuilder:
     #[staticmethod]
     fn layer(layer: String) -> PyEdgeViewPropsFilterBuilder {
         PyEdgeViewPropsFilterBuilder(Arc::new(ExplodedEdgeFilter.layer(layer)))
@@ -173,7 +173,7 @@ impl PyExplodedEdgeFilter {
     ///     layers (list[str]): Layer names.
     ///
     /// Returns:
-    ///     filter.EdgeViewPropsFilterBuilder
+    ///     filter.EdgeViewPropsFilterBuilder:
     #[staticmethod]
     fn layers(layers: FromIterable<String>) -> PyEdgeViewPropsFilterBuilder {
         PyEdgeViewPropsFilterBuilder(Arc::new(ExplodedEdgeFilter.layer(layers)))
@@ -182,7 +182,7 @@ impl PyExplodedEdgeFilter {
     /// Matches exploded edges that have at least one event in the current view.
     ///
     /// Returns:
-    ///     filter.FilterExpr
+    ///     filter.FilterExpr:
     #[staticmethod]
     fn is_active() -> PyFilterExpr {
         PyFilterExpr(Arc::new(ExplodedEdgeFilter.is_active()))
@@ -191,7 +191,7 @@ impl PyExplodedEdgeFilter {
     /// Matches exploded edges that are structurally valid in the current view.
     ///
     /// Returns:
-    ///     filter.FilterExpr
+    ///     filter.FilterExpr:
     #[staticmethod]
     fn is_valid() -> PyFilterExpr {
         PyFilterExpr(Arc::new(ExplodedEdgeFilter.is_valid()))
@@ -200,7 +200,7 @@ impl PyExplodedEdgeFilter {
     /// Matches exploded edges that have been deleted.
     ///
     /// Returns:
-    ///     filter.FilterExpr
+    ///     filter.FilterExpr:
     #[staticmethod]
     fn is_deleted() -> PyFilterExpr {
         PyFilterExpr(Arc::new(ExplodedEdgeFilter.is_deleted()))
@@ -209,7 +209,7 @@ impl PyExplodedEdgeFilter {
     /// Matches exploded edges that are self-loops (source == destination).
     ///
     /// Returns:
-    ///     filter.FilterExpr
+    ///     filter.FilterExpr:
     #[staticmethod]
     fn is_self_loop() -> PyFilterExpr {
         PyFilterExpr(Arc::new(ExplodedEdgeFilter.is_self_loop()))
diff --git a/raphtory/src/python/filter/graph_filter.rs b/raphtory/src/python/filter/graph_filter.rs
index eedcba05d7..259da4187a 100644
--- a/raphtory/src/python/filter/graph_filter.rs
+++ b/raphtory/src/python/filter/graph_filter.rs
@@ -38,7 +38,7 @@ impl PyGraphFilter {
     ///     end (int): End time.
     ///
     /// Returns:
-    ///     filter.ViewFilterBuilder
+    ///     filter.ViewFilterBuilder:
     #[staticmethod]
     fn window(start: EventTime, end: EventTime) -> PyViewFilterBuilder {
         PyViewFilterBuilder(Arc::new(GraphFilter.window(start, end)))
@@ -50,7 +50,7 @@ impl PyGraphFilter {
     ///     time (int): Event time.
     ///
     /// Returns:
-    ///     filter.ViewFilterBuilder
+    ///     filter.ViewFilterBuilder:
     #[staticmethod]
     fn at(time: EventTime) -> PyViewFilterBuilder {
         PyViewFilterBuilder(Arc::new(GraphFilter.at(time)))
@@ -62,7 +62,7 @@ impl PyGraphFilter {
     ///     time (int): Lower time bound.
     ///
     /// Returns:
-    ///     filter.ViewFilterBuilder
+    ///     filter.ViewFilterBuilder:
     #[staticmethod]
     fn after(time: EventTime) -> PyViewFilterBuilder {
         PyViewFilterBuilder(Arc::new(GraphFilter.after(time)))
@@ -74,7 +74,7 @@ impl PyGraphFilter {
     ///     time (int): Upper time bound.
     ///
     /// Returns:
-    ///     filter.ViewFilterBuilder
+    ///     filter.ViewFilterBuilder:
     #[staticmethod]
     fn before(time: EventTime) -> PyViewFilterBuilder {
         PyViewFilterBuilder(Arc::new(GraphFilter.before(time)))
@@ -83,7 +83,7 @@ impl PyGraphFilter {
     /// Evaluates filters against the latest available state of the graph.
     ///
     /// Returns:
-    ///     filter.ViewFilterBuilder
+    ///     filter.ViewFilterBuilder:
     #[staticmethod]
     fn latest() -> PyViewFilterBuilder {
         PyViewFilterBuilder(Arc::new(GraphFilter.latest()))
@@ -95,7 +95,7 @@ impl PyGraphFilter {
     ///     time (int): Snapshot time.
     ///
     /// Returns:
-    ///     filter.ViewFilterBuilder
+    ///     filter.ViewFilterBuilder:
     #[staticmethod]
     fn snapshot_at(time: EventTime) -> PyViewFilterBuilder {
         PyViewFilterBuilder(Arc::new(GraphFilter.snapshot_at(time)))
@@ -104,7 +104,7 @@ impl PyGraphFilter {
     /// Evaluates filters against the most recent snapshot of the graph.
     ///
     /// Returns:
-    ///     filter.ViewFilterBuilder
+    ///     filter.ViewFilterBuilder:
     #[staticmethod]
     fn snapshot_latest() -> PyViewFilterBuilder {
         PyViewFilterBuilder(Arc::new(GraphFilter.snapshot_latest()))
@@ -116,7 +116,7 @@ impl PyGraphFilter {
     ///     layer (str): Layer name.
     ///
     /// Returns:
-    ///     filter.ViewFilterBuilder
+    ///     filter.ViewFilterBuilder:
     #[staticmethod]
     fn layer(layer: String) -> PyViewFilterBuilder {
         PyViewFilterBuilder(Arc::new(GraphFilter.layer(layer)))
@@ -128,7 +128,7 @@ impl PyGraphFilter {
     ///     layers (list[str]): Layer names.
     ///
     /// Returns:
-    ///     filter.ViewFilterBuilder
+    ///     filter.ViewFilterBuilder:
     #[staticmethod]
     fn layers(layers: FromIterable<String>) -> PyViewFilterBuilder {
         PyViewFilterBuilder(Arc::new(GraphFilter.layer(layers)))
diff --git a/raphtory/src/python/filter/node_filter_builders.rs b/raphtory/src/python/filter/node_filter_builders.rs
index 838fb4c616..01613b34b0 100644
--- a/raphtory/src/python/filter/node_filter_builders.rs
+++ b/raphtory/src/python/filter/node_filter_builders.rs
@@ -41,7 +41,6 @@ pub struct PyNodeIdFilterBuilder(Arc<NodeIdFilterBuilder>);
 impl PyNodeIdFilterBuilder {
     /// Returns a filter expression that checks whether the node ID
     /// is equal to the given value.
-    ///pub(crate) pub(crate)
     /// Arguments:
     ///     value (int): Node ID to compare against.
     ///
@@ -380,7 +379,7 @@ impl PyNodeFilter {
     /// Selects the node ID field for filtering.
     ///
     /// Returns:
-    ///     filter.NodeIdFilterBuilder
+    ///     filter.NodeIdFilterBuilder:
     #[staticmethod]
     fn id() -> PyNodeIdFilterBuilder {
         PyNodeIdFilterBuilder(Arc::new(NodeFilter::id()))
@@ -389,7 +388,7 @@ impl PyNodeFilter {
     /// Selects the node name field for filtering.
     ///
     /// Returns:
-    ///     filter.NodeNameFilterBuilder
+    ///     filter.NodeNameFilterBuilder:
     #[staticmethod]
     fn name() -> PyNodeNameFilterBuilder {
         PyNodeNameFilterBuilder(Arc::new(NodeFilter::name()))
@@ -398,7 +397,7 @@ impl PyNodeFilter {
     /// Selects the node type field for filtering.
     ///
     /// Returns:
-    ///     filter.NodeTypeFilterBuilder
+    ///     filter.NodeTypeFilterBuilder:
     #[staticmethod]
     fn node_type() -> PyNodeTypeFilterBuilder {
         PyNodeTypeFilterBuilder(Arc::new(NodeFilter::node_type()))
@@ -412,7 +411,7 @@ impl PyNodeFilter {
     ///     name (str): Property key.
     ///
     /// Returns:
-    ///     filter.PropertyFilterOps
+    ///     filter.PropertyFilterOps:
     #[staticmethod]
     fn property<'py>(
         py: Python<'py>,
@@ -431,7 +430,7 @@ impl PyNodeFilter {
     ///     name (str): Metadata key.
     ///
     /// Returns:
-    ///     filter.FilterOps
+    ///     filter.FilterOps:
     #[staticmethod]
     fn metadata<'py>(py: Python<'py>, name: String) -> PyResult<Bound<'py, PyPropertyExprBuilder>> {
         let b: MetadataFilterBuilder<NodeFilter> =
@@ -448,7 +447,7 @@ impl PyNodeFilter {
     ///     end (int): End time.
     ///
     /// Returns:
-    ///     filter.NodeViewPropsFilterBuilder
+    ///     filter.NodeViewPropsFilterBuilder:
     #[staticmethod]
     fn window(start: EventTime, end: EventTime) -> PyNodeViewPropsFilterBuilder {
         PyNodeViewPropsFilterBuilder(Arc::new(NodeFilter.window(start, end)))
@@ -460,7 +459,7 @@ impl PyNodeFilter {
     ///     time (int): Event time.
     ///
     /// Returns:
-    ///     filter.NodeViewPropsFilterBuilder
+    ///     filter.NodeViewPropsFilterBuilder:
     #[staticmethod]
     fn at(time: EventTime) -> PyNodeViewPropsFilterBuilder {
         PyNodeViewPropsFilterBuilder(Arc::new(NodeFilter.at(time)))
@@ -472,7 +471,7 @@ impl PyNodeFilter {
     ///     time (int): Lower time bound.
     ///
     /// Returns:
-    ///     filter.NodeViewPropsFilterBuilder
+    ///     filter.NodeViewPropsFilterBuilder:
     #[staticmethod]
     fn after(time: EventTime) -> PyNodeViewPropsFilterBuilder {
         PyNodeViewPropsFilterBuilder(Arc::new(NodeFilter.after(time)))
@@ -484,7 +483,7 @@ impl PyNodeFilter {
     ///     time (int): Upper time bound.
     ///
     /// Returns:
-    ///     filter.NodeViewPropsFilterBuilder
+    ///     filter.NodeViewPropsFilterBuilder:
     #[staticmethod]
     fn before(time: EventTime) -> PyNodeViewPropsFilterBuilder {
         PyNodeViewPropsFilterBuilder(Arc::new(NodeFilter.before(time)))
@@ -493,7 +492,7 @@ impl PyNodeFilter {
     /// Evaluates filters against the latest available state of each node.
     ///
     /// Returns:
-    ///     filter.NodeViewPropsFilterBuilder
+    ///     filter.NodeViewPropsFilterBuilder:
     #[staticmethod]
     fn latest() -> PyNodeViewPropsFilterBuilder {
         PyNodeViewPropsFilterBuilder(Arc::new(NodeFilter.latest()))
@@ -505,7 +504,7 @@ impl PyNodeFilter {
     ///     time (int): Snapshot time.
     ///
     /// Returns:
-    ///     filter.NodeViewPropsFilterBuilder
+    ///     filter.NodeViewPropsFilterBuilder:
     #[staticmethod]
     fn snapshot_at(time: EventTime) -> PyNodeViewPropsFilterBuilder {
         PyNodeViewPropsFilterBuilder(Arc::new(NodeFilter.snapshot_at(time)))
@@ -514,7 +513,7 @@ impl PyNodeFilter {
     /// Evaluates filters against the most recent snapshot of the graph.
     ///
     /// Returns:
-    ///     filter.NodeViewPropsFilterBuilder
+    ///     filter.NodeViewPropsFilterBuilder:
     #[staticmethod]
     fn snapshot_latest() -> PyNodeViewPropsFilterBuilder {
         PyNodeViewPropsFilterBuilder(Arc::new(NodeFilter.snapshot_latest()))
@@ -526,7 +525,7 @@ impl PyNodeFilter {
     ///     layer (str): Layer name.
     ///
     /// Returns:
-    ///     filter.NodeViewPropsFilterBuilder
+    ///     filter.NodeViewPropsFilterBuilder:
     #[staticmethod]
     fn layer(layer: String) -> PyNodeViewPropsFilterBuilder {
         PyNodeViewPropsFilterBuilder(Arc::new(NodeFilter.layer(layer)))
@@ -538,7 +537,7 @@ impl PyNodeFilter {
     ///     layers (list[str]): Layer names.
     ///
     /// Returns:
-    ///     filter.NodeViewPropsFilterBuilder
+    ///     filter.NodeViewPropsFilterBuilder:
     #[staticmethod]
     fn layers(layers: FromIterable<String>) -> PyNodeViewPropsFilterBuilder {
         PyNodeViewPropsFilterBuilder(Arc::new(NodeFilter.layer(layers)))
@@ -547,12 +546,20 @@ impl PyNodeFilter {
     /// Matches nodes that have at least one event in the current view.
     ///
     /// Returns:
-    ///     filter.FilterExpr
+    ///     filter.FilterExpr:
     #[staticmethod]
     fn is_active() -> PyFilterExpr {
         PyFilterExpr(Arc::new(NodeFilter.is_active()))
     }
 
+    /// Build a node filter from a boolean column of an existing node-state result.
+    ///
+    /// Arguments:
+    ///     state (OutputNodeState): A pre-computed node state (e.g. from an algorithm).
+    ///     col (str): Name of the boolean column on `state` whose values determine inclusion.
+    ///
+    /// Returns:
+    ///     filter.FilterExpr:
     #[staticmethod]
     fn by_state_column(state: &PyOutputNodeState, col: String) -> PyResult<PyFilterExpr> {
         let op = NodeStateBoolColOp::new(&state.inner, &col)
diff --git a/raphtory/src/python/filter/property_filter_builders.rs b/raphtory/src/python/filter/property_filter_builders.rs
index 8e3d83fed4..17eb3b49de 100644
--- a/raphtory/src/python/filter/property_filter_builders.rs
+++ b/raphtory/src/python/filter/property_filter_builders.rs
@@ -216,46 +216,73 @@ impl PyPropertyExprBuilder {
     }
 
     /// Selects the first element when the underlying property is list-like.
+    ///
+    /// Returns:
+    ///     filter.PropertyFilterOps:
     pub fn first(&self) -> PyPropertyExprBuilder {
         PyPropertyExprBuilder(self.0.first())
     }
 
     /// Selects the last element when the underlying property is list-like.
+    ///
+    /// Returns:
+    ///     filter.PropertyFilterOps:
     pub fn last(&self) -> PyPropertyExprBuilder {
         PyPropertyExprBuilder(self.0.last())
     }
 
     /// Requires that **any** element matches when the underlying property is list-like.
+    ///
+    /// Returns:
+    ///     filter.PropertyFilterOps:
     pub fn any(&self) -> PyPropertyExprBuilder {
         PyPropertyExprBuilder(self.0.any())
     }
 
     /// Requires that **all** elements match when the underlying property is list-like.
+    ///
+    /// Returns:
+    ///     filter.PropertyFilterOps:
     pub fn all(&self) -> PyPropertyExprBuilder {
         PyPropertyExprBuilder(self.0.all())
     }
 
     /// Returns the list length when the underlying property is list-like.
+    ///
+    /// Returns:
+    ///     filter.PropertyFilterOps:
     fn len(&self) -> PyPropertyExprBuilder {
         PyPropertyExprBuilder(self.0.len())
     }
 
     /// Sums list elements when the underlying property is numeric and list-like.
+    ///
+    /// Returns:
+    ///     filter.PropertyFilterOps:
     fn sum(&self) -> PyPropertyExprBuilder {
         PyPropertyExprBuilder(self.0.sum())
     }
 
     /// Averages list elements when the underlying property is numeric and list-like.
+    ///
+    /// Returns:
+    ///     filter.PropertyFilterOps:
     fn avg(&self) -> PyPropertyExprBuilder {
         PyPropertyExprBuilder(self.0.avg())
     }
 
     /// Returns the minimum list element when the underlying property is list-like.
+    ///
+    /// Returns:
+    ///     filter.PropertyFilterOps:
     fn min(&self) -> PyPropertyExprBuilder {
         PyPropertyExprBuilder(self.0.min())
     }
 
     /// Returns the maximum list element when the underlying property is list-like.
+    ///
+    /// Returns:
+    ///     filter.PropertyFilterOps:
     fn max(&self) -> PyPropertyExprBuilder {
         PyPropertyExprBuilder(self.0.max())
     }
@@ -402,7 +429,7 @@ impl PyViewFilterBuilder {
     ///     end (int): End time.
     ///
     /// Returns:
-    ///     filter.ViewFilterBuilder
+    ///     filter.ViewFilterBuilder:
     fn window(&self, start: EventTime, end: EventTime) -> PyViewFilterBuilder {
         PyViewFilterBuilder(self.0.clone().window(start, end))
     }
@@ -413,7 +440,7 @@ impl PyViewFilterBuilder {
     ///     time (int): Event time.
     ///
     /// Returns:
-    ///     filter.ViewFilterBuilder
+    ///     filter.ViewFilterBuilder:
     fn at(&self, time: EventTime) -> PyViewFilterBuilder {
         PyViewFilterBuilder(self.0.clone().at(time))
     }
@@ -494,7 +521,7 @@ impl PyNodeViewPropsFilterBuilder {
     ///     name (str): Property key.
     ///
     /// Returns:
-    ///     filter.PropertyFilterOps
+    ///     filter.PropertyFilterOps:
     fn property(&self, name: String) -> PyPropertyFilterBuilder {
         PyPropertyFilterBuilder(self.0.property(name))
     }
diff --git a/raphtory/src/python/graph/disk_graph.rs b/raphtory/src/python/graph/disk_graph.rs
deleted file mode 100644
index d96089c459..0000000000
--- a/raphtory/src/python/graph/disk_graph.rs
+++ /dev/null
@@ -1,326 +0,0 @@
-//! A columnar temporal graph.
-//!
-use crate::{
-    db::{
-        api::storage::graph::storage_ops::disk_storage::IntoGraph,
-        graph::views::deletion_graph::PersistentGraph,
-    },
-    errors::GraphError,
-    io::parquet_loaders::read_struct_arrays,
-    prelude::Graph,
-    python::{
-        graph::{
-            graph::PyGraph,
-            io::arrow_loaders::{convert_py_prop_args, process_arrow_c_stream_df},
-        },
-        types::repr::StructReprBuilder,
-    },
-};
-use arrow::{array::StructArray, datatypes::Field};
-use itertools::Itertools;
-use pometry_storage::{
-    graph::{load_node_metadata, TemporalGraph},
-    RAError,
-};
-use pyo3::{exceptions::PyRuntimeError, prelude::*, pybacked::PyBackedStr, types::PyDict};
-use raphtory_storage::disk::{DiskGraphStorage, ParquetLayerCols};
-use std::{
-    ops::Deref,
-    path::{Path, PathBuf},
-    str::FromStr,
-};
-
-#[derive(Clone)]
-#[pyclass(name = "DiskGraphStorage", frozen, module = "raphtory")]
-pub struct PyDiskGraph(pub DiskGraphStorage);
-
-impl<G> AsRef<G> for PyDiskGraph
-where
-    DiskGraphStorage: AsRef<G>,
-{
-    fn as_ref(&self) -> &G {
-        self.0.as_ref()
-    }
-}
-
-impl From<DiskGraphStorage> for PyDiskGraph {
-    fn from(value: DiskGraphStorage) -> Self {
-        Self(value)
-    }
-}
-
-impl From<PyDiskGraph> for DiskGraphStorage {
-    fn from(value: PyDiskGraph) -> Self {
-        value.0
-    }
-}
-
-struct PyParquetLayerCols {
-    parquet_dir: PyBackedStr,
-    layer: PyBackedStr,
-    src_col: PyBackedStr,
-    dst_col: PyBackedStr,
-    time_col: PyBackedStr,
-    exclude_edge_props: Vec<PyBackedStr>,
-}
-
-impl PyParquetLayerCols {
-    pub fn as_deref(&self) -> ParquetLayerCols<'_> {
-        ParquetLayerCols {
-            parquet_dir: self.parquet_dir.deref(),
-            layer: self.layer.deref(),
-            src_col: self.src_col.deref(),
-            dst_col: self.dst_col.deref(),
-            time_col: self.time_col.deref(),
-            exclude_edge_props: self.exclude_edge_props.iter().map(|s| s.deref()).collect(),
-        }
-    }
-}
-
-impl<'a> FromPyObject<'a> for PyParquetLayerCols {
-    fn extract_bound(obj: &Bound<'a, PyAny>) -> PyResult<Self> {
-        let dict = obj.downcast::<PyDict>()?;
-        Ok(PyParquetLayerCols {
-            parquet_dir: dict
-                .get_item("parquet_dir")?
-                .ok_or(PyRuntimeError::new_err("parquet_dir is required"))?
-                .extract::<PyBackedStr>()?,
-            layer: dict
-                .get_item("layer")?
-                .ok_or(PyRuntimeError::new_err("layer is  required"))?
-                .extract::<PyBackedStr>()?,
-            src_col: dict
-                .get_item("src_col")?
-                .ok_or(PyRuntimeError::new_err("src_col is required"))?
-                .extract::<PyBackedStr>()?,
-            dst_col: dict
-                .get_item("dst_col")?
-                .ok_or(PyRuntimeError::new_err("dst_col is required"))?
-                .extract::<PyBackedStr>()?,
-            time_col: dict
-                .get_item("time_col")?
-                .ok_or(PyRuntimeError::new_err("time_col is required"))?
-                .extract::<PyBackedStr>()?,
-            exclude_edge_props: match dict.get_item("exclude_edge_props")? {
-                None => Ok(vec![]),
-                Some(item) => item
-                    .try_iter()?
-                    .map(|v| v.and_then(|v| v.extract::<PyBackedStr>()))
-                    .collect::<PyResult<Vec<_>>>(),
-            }?,
-        })
-    }
-}
-
-#[pymethods]
-impl PyGraph {
-    /// save graph in disk_graph format and memory map the result
-    ///
-    /// Arguments:
-    ///     graph_dir (str | PathLike): folder where the graph will be saved
-    ///
-    /// Returns:
-    ///     DiskGraphStorage: the persisted graph storage
-    pub fn persist_as_disk_graph(&self, graph_dir: PathBuf) -> Result<PyDiskGraph, GraphError> {
-        Ok(PyDiskGraph(DiskGraphStorage::from_graph(
-            &self.graph,
-            &graph_dir,
-        )?))
-    }
-}
-
-#[pymethods]
-impl PyDiskGraph {
-    pub fn graph_dir(&self) -> &Path {
-        self.0.graph_dir()
-    }
-
-    pub fn to_events(&self) -> Graph {
-        self.0.clone().into_graph()
-    }
-
-    pub fn to_persistent(&self) -> PersistentGraph {
-        self.0.clone().into_persistent_graph()
-    }
-
-    #[staticmethod]
-    #[pyo3(signature = (graph_dir, edge_df, time_col, src_col, dst_col))]
-    pub fn load_from_pandas(
-        graph_dir: PathBuf,
-        edge_df: &Bound<PyAny>,
-        time_col: &str,
-        src_col: &str,
-        dst_col: &str,
-    ) -> Result<PyDiskGraph, GraphError> {
-        let cols_to_check = vec![src_col, dst_col, time_col];
-
-        let df_columns: Vec<String> = edge_df.getattr("columns")?.extract()?;
-        let df_columns: Vec<&str> = df_columns.iter().map(|x| x.as_str()).collect();
-
-        let df_view = process_arrow_c_stream_df(edge_df, df_columns, None)?;
-        df_view.check_cols_exist(&cols_to_check)?;
-        let src_index = df_view.get_index(src_col)?;
-        let dst_index = df_view.get_index(dst_col)?;
-        let time_index = df_view.get_index(time_col)?;
-
-        let mut chunks_iter = df_view.chunks.peekable();
-        let chunk_size = if let Some(result) = chunks_iter.peek() {
-            match result {
-                Ok(df) => df.chunk.len(),
-                Err(e) => {
-                    return Err(GraphError::LoadFailure(format!(
-                        "Failed to load graph {e:?}"
-                    )))
-                }
-            }
-        } else {
-            return Err(GraphError::LoadFailure("No chunks available".to_string()));
-        };
-
-        let edge_lists = chunks_iter
-            .map_ok(|df| {
-                let fields = df
-                    .chunk
-                    .iter()
-                    .zip(df_view.names.iter())
-                    .map(|(arr, col_name)| {
-                        Field::new(col_name, arr.data_type().clone(), arr.null_count() > 0)
-                    })
-                    .collect_vec();
-                let s_array = StructArray::new(fields.into(), df.chunk, None);
-                s_array
-            })
-            .collect::<Result<Vec<_>, GraphError>>()?;
-
-        let graph = DiskGraphStorage::load_from_edge_lists(
-            &edge_lists,
-            chunk_size,
-            chunk_size,
-            graph_dir,
-            time_index,
-            src_index,
-            dst_index,
-        )?;
-
-        Ok(PyDiskGraph(graph))
-    }
-
-    #[staticmethod]
-    fn load_from_dir(graph_dir: PathBuf) -> Result<PyDiskGraph, GraphError> {
-        DiskGraphStorage::load_from_dir(&graph_dir)
-            .map_err(|err| {
-                GraphError::LoadFailure(format!(
-                    "Failed to load graph {err:?} from dir {}",
-                    graph_dir.display()
-                ))
-            })
-            .map(PyDiskGraph)
-    }
-
-    #[staticmethod]
-    #[pyo3(
-        signature = (graph_dir, layer_parquet_cols, node_properties=None, chunk_size=10_000_000, t_props_chunk_size=10_000_000, num_threads=4, node_type_col=None, node_id_col=None, num_rows=None)
-    )]
-    fn load_from_parquets(
-        graph_dir: PathBuf,
-        layer_parquet_cols: Vec<PyParquetLayerCols>,
-        node_properties: Option<PathBuf>,
-        chunk_size: usize,
-        t_props_chunk_size: usize,
-        num_threads: usize,
-        node_type_col: Option<&str>,
-        node_id_col: Option<&str>,
-        num_rows: Option<usize>,
-    ) -> Result<PyDiskGraph, GraphError> {
-        let layer_cols = layer_parquet_cols
-            .iter()
-            .map(|layer| layer.as_deref())
-            .collect();
-        DiskGraphStorage::load_from_parquets(
-            graph_dir,
-            layer_cols,
-            node_properties,
-            chunk_size,
-            t_props_chunk_size,
-            num_threads,
-            node_type_col,
-            node_id_col,
-            num_rows,
-        )
-        .map_err(|err| {
-            GraphError::LoadFailure(format!("Failed to load graph from parquet files: {err:?}"))
-        })
-        .map(PyDiskGraph)
-    }
-
-    #[pyo3(signature = (location, col_names=None, chunk_size=None))]
-    pub fn load_node_metadata(
-        &self,
-        location: PathBuf,
-        col_names: Option<Vec<PyBackedStr>>,
-        chunk_size: Option<usize>,
-    ) -> Result<PyDiskGraph, GraphError> {
-        let col_names = convert_py_prop_args(col_names.as_deref());
-        let chunks = read_struct_arrays(&location, col_names.as_deref())?;
-        let _ = load_node_metadata(chunk_size.unwrap_or(200_000), self.graph_dir(), chunks)?;
-        Self::load_from_dir(self.graph_dir().to_path_buf())
-    }
-
-    #[pyo3(signature=(location, col_name, chunk_size=None))]
-    pub fn load_node_types(
-        &self,
-        location: PathBuf,
-        col_name: &str,
-        chunk_size: Option<usize>,
-    ) -> Result<PyDiskGraph, GraphError> {
-        let mut cloned = self.clone();
-        let chunks = read_struct_arrays(&location, Some(&[col_name]))?.map(|chunk| match chunk {
-            Ok(chunk) => {
-                let (_, cols, _) = chunk.into_parts();
-                cols.into_iter().next().ok_or(RAError::EmptyChunk)
-            }
-            Err(err) => Err(err),
-        });
-        cloned
-            .0
-            .load_node_types_from_arrays(chunks, chunk_size.unwrap_or(1_000_000))?;
-        Ok(cloned)
-    }
-
-    #[pyo3(signature = (location, chunk_size=20_000_000))]
-    pub fn append_node_temporal_properties(
-        &self,
-        location: &str,
-        chunk_size: usize,
-    ) -> Result<PyDiskGraph, GraphError> {
-        let path = PathBuf::from_str(location).unwrap();
-        let chunks = read_struct_arrays(&path, None)?;
-        let mut graph = TemporalGraph::new(self.0.inner().graph_dir())?;
-        graph.load_temporal_node_props_from_chunks(chunks, chunk_size, false)?;
-        Self::load_from_dir(self.graph_dir().to_path_buf())
-    }
-
-    /// Merge this graph with another `DiskGraph`. Note that both graphs should have nodes that are
-    /// sorted by their global ids or the resulting graph will be nonsense!
-    fn merge_by_sorted_gids(
-        &self,
-        other: &Self,
-        graph_dir: PathBuf,
-    ) -> Result<PyDiskGraph, GraphError> {
-        Ok(PyDiskGraph(
-            self.0.merge_by_sorted_gids(&other.0, graph_dir)?,
-        ))
-    }
-
-    fn __repr__(&self) -> String {
-        StructReprBuilder::new("DiskGraph")
-            .add_field("number_of_nodes", self.0.inner.num_nodes())
-            .add_field(
-                "number_of_temporal_edges",
-                self.0.inner.count_temporal_edges(),
-            )
-            .add_field("earliest_time", self.0.inner.earliest())
-            .add_field("latest_time", self.0.inner.latest())
-            .finish()
-    }
-}
diff --git a/raphtory/src/python/graph/edges.rs b/raphtory/src/python/graph/edges.rs
index f6b756dd89..bf38ad847a 100644
--- a/raphtory/src/python/graph/edges.rs
+++ b/raphtory/src/python/graph/edges.rs
@@ -27,7 +27,7 @@ use crate::{
         utils::export::{create_row, extract_properties, get_column_names_from_props},
     },
 };
-use pyo3::{prelude::*, types::PyDict};
+use pyo3::{prelude::*, types::PyDict, Py, PyAny};
 use raphtory_api::core::storage::arc_str::ArcStr;
 use raphtory_storage::core_ops::CoreGraphOps;
 use rayon::{iter::IntoParallelIterator, prelude::*};
@@ -262,7 +262,7 @@ impl PyEdges {
         include_property_history: bool,
         convert_datetime: bool,
         mut explode: bool,
-    ) -> PyResult<PyObject> {
+    ) -> PyResult<Py<PyAny>> {
         let mut column_names = vec![
             String::from("src"),
             String::from("dst"),
@@ -304,8 +304,8 @@ impl PyEdges {
                 );
 
                 let row_header: Vec<Prop> = vec![
-                    Prop::from(item.src().name()),
-                    Prop::from(item.dst().name()),
+                    Prop::Str(item.src().name().into()),
+                    Prop::Str(item.dst().name().into()),
                     Prop::from(item.layer_name().unwrap_or(ArcStr::from(""))),
                 ];
 
@@ -325,7 +325,7 @@ impl PyEdges {
             })
             .collect();
 
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let pandas = PyModule::import(py, "pandas")?;
             let kwargs = PyDict::new(py);
             kwargs.set_item("columns", column_names)?;
diff --git a/raphtory/src/python/graph/graph.rs b/raphtory/src/python/graph/graph.rs
index 0ee04beae2..40d939d9be 100644
--- a/raphtory/src/python/graph/graph.rs
+++ b/raphtory/src/python/graph/graph.rs
@@ -3,6 +3,8 @@
 //! This is the base class used to create a temporal graph, add nodes and edges,
 //! create windows, and query the graph with a variety of algorithms.
 //! In Python, this class wraps around the rust graph.
+#[cfg(feature = "search")]
+use crate::python::graph::index::PyIndexSpec;
 use crate::{
     algorithms::components::LargestConnectedComponent,
     db::{
@@ -10,13 +12,13 @@ use crate::{
         graph::{edge::EdgeView, node::NodeView, views::node_subgraph::NodeSubgraph},
     },
     errors::GraphError,
-    io::parquet_loaders::*,
+    io::{arrow::df_loaders::edges::ColumnNames, parquet_loaders::*},
     prelude::*,
     python::{
+        config::PyConfig,
         graph::{
             edge::PyEdge,
             graph_with_deletions::PyPersistentGraph,
-            index::PyIndexSpec,
             io::arrow_loaders::{
                 convert_py_prop_args, convert_py_schema, is_csv_path,
                 load_edge_metadata_from_arrow_c_stream, load_edge_metadata_from_csv_path,
@@ -30,12 +32,9 @@ use crate::{
         types::iterable::FromIterable,
         utils::PyNodeRef,
     },
-    serialise::{
-        parquet::{ParquetDecoder, ParquetEncoder},
-        InternalStableDecode, StableEncode,
-    },
+    serialise::{StableDecode, StableEncode},
 };
-use pyo3::{exceptions::PyValueError, prelude::*, pybacked::PyBackedStr, types::PyDict};
+use pyo3::{exceptions::PyValueError, prelude::*, pybacked::PyBackedStr, types::PyDict, Borrowed};
 use raphtory_api::{
     core::{entities::GID, storage::arc_str::ArcStr},
     python::timeindex::EventTimeComponent,
@@ -51,7 +50,8 @@ use std::{
 /// A temporal graph with event semantics.
 ///
 /// Arguments:
-///     num_shards (int, optional): The number of locks to use in the storage to allow for multithreaded updates.
+///     path (str | PathLike, optional): The path for persisting the graph (only works with disk storage enabled)
+///     config (Config, optional): The configuration options for the graph
 #[derive(Clone)]
 #[pyclass(name = "Graph", extends = PyGraphView, module = "raphtory", frozen)]
 pub struct PyGraph {
@@ -96,8 +96,9 @@ impl From<PyGraph> for DynamicGraph {
     }
 }
 
-impl<'source> FromPyObject<'source> for MaterializedGraph {
-    fn extract_bound(graph: &Bound<'source, PyAny>) -> PyResult<Self> {
+impl<'py> FromPyObject<'_, 'py> for MaterializedGraph {
+    type Error = PyErr;
+    fn extract(graph: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
         if let Ok(graph) = graph.extract::<PyRef<PyGraph>>() {
             Ok(graph.graph.clone().into())
         } else if let Ok(graph) = graph.extract::<PyRef<PyPersistentGraph>>() {
@@ -120,9 +121,10 @@ impl<'py> IntoPyObject<'py> for Graph {
     }
 }
 
-impl<'source> FromPyObject<'source> for Graph {
-    fn extract_bound(ob: &Bound<'source, PyAny>) -> PyResult<Self> {
-        let g = ob.downcast::<PyGraph>()?.borrow();
+impl<'py> FromPyObject<'_, 'py> for Graph {
+    type Error = PyErr;
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
+        let g = ob.cast::<PyGraph>()?.borrow();
 
         Ok(g.graph.clone())
     }
@@ -130,7 +132,7 @@ impl<'source> FromPyObject<'source> for Graph {
 
 impl PyGraph {
     pub fn py_from_db_graph(db_graph: Graph) -> PyResult<Py<PyGraph>> {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             Py::new(
                 py,
                 (PyGraph::from(db_graph.clone()), PyGraphView::from(db_graph)),
@@ -160,38 +162,61 @@ impl PyGraphEncoder {
 #[pymethods]
 impl PyGraph {
     #[new]
-    #[pyo3(signature = (num_shards = None))]
-    pub fn py_new(num_shards: Option<usize>) -> (Self, PyGraphView) {
-        let graph = match num_shards {
-            None => Graph::new(),
-            Some(num_shards) => Graph::new_with_shards(num_shards),
+    #[pyo3(signature = (path = None, config=None))]
+    pub fn py_new(
+        path: Option<PathBuf>,
+        config: Option<PyConfig>,
+    ) -> Result<(Self, PyGraphView), GraphError> {
+        let graph = match path {
+            None => match config {
+                None => Graph::new(),
+                Some(PyConfig(config)) => Graph::new_with_config(config)?,
+            },
+            Some(path) => match config {
+                None => Graph::new_at_path(&path)?,
+                Some(PyConfig(config)) => Graph::new_at_path_with_config(&path, config)?,
+            },
         };
-        (
+        Ok((
             Self {
                 graph: graph.clone(),
             },
             PyGraphView::from(graph),
-        )
-    }
-
-    fn __reduce__(&self) -> (PyGraphEncoder, (Vec<u8>,)) {
-        let state = self.graph.encode_to_vec();
-        (PyGraphEncoder, (state,))
+        ))
     }
 
-    /// Persist graph on disk
+    /// Load a disk graph from path
     ///
     /// Arguments:
-    ///     graph_dir (str | PathLike): the folder where the graph will be persisted
+    ///     path (str | PathLike): the path of the graph folder
+    ///     config (Config, optional): specify a new config to override the values saved for the graph
+    ///                                (note that the page sizes cannot be overridden and are ignored)
     ///
     /// Returns:
-    ///     Graph: a view of the persisted graph
-    #[cfg(feature = "storage")]
-    pub fn to_disk_graph(&self, graph_dir: PathBuf) -> Result<Graph, GraphError> {
-        self.graph.persist_as_disk_graph(graph_dir)
+    ///     Graph: the graph
+    #[pyo3(signature = (path, config = None))]
+    #[staticmethod]
+    pub fn load(path: PathBuf, config: Option<PyConfig>) -> Result<Graph, GraphError> {
+        match config {
+            None => Graph::load(&path),
+            Some(PyConfig(config)) => Graph::load_with_config(&path, config),
+        }
     }
 
-    /// Persist graph to parquet files.
+    /// Trigger a flush of the underlying storage if disk storage is enabled
+    ///
+    /// Returns:
+    ///     None: This function does not return a value, if the operation is successful.
+    pub fn flush(&self) -> Result<(), GraphError> {
+        self.graph.flush()
+    }
+
+    fn __reduce__(&self) -> Result<(PyGraphEncoder, (Vec<u8>,)), GraphError> {
+        let state = self.graph.encode_to_bytes()?;
+        Ok((PyGraphEncoder, (state,)))
+    }
+
+    /// Persist graph to parquet files
     ///
     /// Arguments:
     ///     graph_dir (str | PathLike): the folder where the graph will be persisted as parquet
@@ -199,7 +224,7 @@ impl PyGraph {
     /// Returns:
     ///     None:
     pub fn to_parquet(&self, graph_dir: PathBuf) -> Result<(), GraphError> {
-        self.graph.encode_parquet(graph_dir)
+        self.graph.encode(graph_dir)
     }
 
     /// Read graph from parquet files
@@ -212,7 +237,7 @@ impl PyGraph {
     ///
     #[staticmethod]
     pub fn from_parquet(graph_dir: PathBuf) -> Result<Graph, GraphError> {
-        Graph::decode_parquet(graph_dir)
+        Graph::decode(&graph_dir)
     }
 
     /// Adds a new node with the given id and properties to the graph.
@@ -223,6 +248,7 @@ impl PyGraph {
     ///    properties (PropInput, optional): The properties of the node.
     ///    node_type (str, optional): The optional string which will be used as a node type.
     ///    event_id (int, optional): The optional integer which will be used as an event id.
+    ///    layer (str, optional): The optional string which will be used as a node layer.
     ///
     /// Returns:
     ///     MutableNode: The added node.
@@ -230,7 +256,7 @@ impl PyGraph {
     /// Raises:
     ///     GraphError: If the operation fails.
     #[pyo3(
-        signature = (timestamp, id, properties = None, node_type = None, event_id = None)
+        signature = (timestamp, id, properties = None, node_type = None, event_id = None, layer = None)
     )]
     pub fn add_node(
         &self,
@@ -239,6 +265,7 @@ impl PyGraph {
         properties: Option<Bound<PyDict>>,
         node_type: Option<&str>,
         event_id: Option<usize>,
+        layer: Option<&str>,
     ) -> Result<NodeView<'static, Graph>, GraphError> {
         let props = properties
             .into_iter()
@@ -250,10 +277,11 @@ impl PyGraph {
             })
             .collect::<Result<Vec<_>, _>>()?;
         match event_id {
-            None => self.graph.add_node(timestamp, id, props, node_type),
-            Some(event_id) => self
-                .graph
-                .add_node((timestamp, event_id), id, props, node_type),
+            None => self.graph.add_node(timestamp, id, props, node_type, layer),
+            Some(event_id) => {
+                self.graph
+                    .add_node((timestamp, event_id), id, props, node_type, layer)
+            }
         }
     }
 
@@ -265,13 +293,13 @@ impl PyGraph {
     ///    properties (PropInput, optional): The properties of the node.
     ///    node_type (str, optional): The optional string which will be used as a node type.
     ///    event_id (int, optional): The optional integer which will be used as an event id.
-    ///
+    ///    layer (str, optional): The optional string which will be used as a layer.
     /// Returns:
     ///     MutableNode: The created node.
     ///
     /// Raises:
     ///     GraphError: If the operation fails.
-    #[pyo3(signature = (timestamp, id, properties = None, node_type = None, event_id = None))]
+    #[pyo3(signature = (timestamp, id, properties = None, node_type = None, event_id = None, layer = None))]
     pub fn create_node(
         &self,
         timestamp: EventTimeComponent,
@@ -279,17 +307,22 @@ impl PyGraph {
         properties: Option<HashMap<String, Prop>>,
         node_type: Option<&str>,
         event_id: Option<usize>,
+        layer: Option<&str>,
     ) -> Result<NodeView<'static, Graph>, GraphError> {
         match event_id {
-            None => {
-                self.graph
-                    .create_node(timestamp, id, properties.unwrap_or_default(), node_type)
-            }
+            None => self.graph.create_node(
+                timestamp,
+                id,
+                properties.unwrap_or_default(),
+                node_type,
+                layer,
+            ),
             Some(event_id) => self.graph.create_node(
                 (timestamp, event_id),
                 id,
                 properties.unwrap_or_default(),
                 node_type,
+                layer,
             ),
         }
     }
@@ -674,6 +707,9 @@ impl PyGraph {
     ///     shared_metadata (PropInput, optional): A dictionary of metadata properties that will be added to every node. Defaults to None.
     ///     schema (list[tuple[str, DataType | PropType | str]] | dict[str, DataType | PropType | str], optional): A list of (column_name, column_type) tuples or dict of {"column_name": column_type} to cast columns to. Defaults to None.
     ///     csv_options (dict[str, str | bool], optional): A dictionary of CSV reading options such as delimiter, comment, escape, quote, and terminator characters, as well as allow_truncated_rows and has_header flags. Defaults to None.
+    ///     event_id (str, optional): The column name for the secondary index. Defaults to None.
+    ///     layer (str, optional): A value to use as the layer for all nodes. Cannot be used in combination with layer_col. Defaults to None.
+    ///     layer_col (str, optional): The node layer column name in a dataframe. Cannot be used in combination with layer. Defaults to None.
     ///
     /// Returns:
     ///     None: This function does not return a value if the operation is successful.
@@ -681,7 +717,7 @@ impl PyGraph {
     /// Raises:
     ///     GraphError: If the operation fails.
     #[pyo3(
-        signature = (data, time, id, node_type = None, node_type_col = None, properties = None, metadata= None, shared_metadata = None, schema = None, csv_options = None)
+        signature = (data, time, id, node_type = None, node_type_col = None, properties = None, metadata= None, shared_metadata = None, schema = None, csv_options = None, event_id = None, layer = None, layer_col = None)
     )]
     fn load_nodes(
         &self,
@@ -695,6 +731,9 @@ impl PyGraph {
         shared_metadata: Option<HashMap<String, Prop>>,
         schema: Option<Bound<PyAny>>,
         csv_options: Option<CsvReadOptions>,
+        event_id: Option<&str>,
+        layer: Option<&str>,
+        layer_col: Option<&str>,
     ) -> Result<(), GraphError> {
         let properties = convert_py_prop_args(properties.as_deref()).unwrap_or_default();
         let metadata = convert_py_prop_args(metadata.as_deref()).unwrap_or_default();
@@ -710,7 +749,10 @@ impl PyGraph {
                 &properties,
                 &metadata,
                 shared_metadata.as_ref(),
+                layer,
+                layer_col,
                 column_schema,
+                event_id,
             )
         } else if let Ok(path) = data.extract::<PathBuf>() {
             // extracting PathBuf handles Strings too
@@ -734,13 +776,17 @@ impl PyGraph {
                     &self.graph,
                     path.as_path(),
                     time,
+                    event_id,
                     id,
                     node_type,
                     node_type_col,
                     &properties,
                     &metadata,
                     shared_metadata.as_ref(),
+                    layer,
+                    layer_col,
                     None,
+                    true,
                     arced_schema.clone(),
                 )?;
             }
@@ -755,8 +801,11 @@ impl PyGraph {
                     &properties,
                     &metadata,
                     shared_metadata.as_ref(),
+                    layer,
+                    layer_col,
                     csv_options.as_ref(),
                     arced_schema,
+                    event_id,
                 )?;
             }
             if !is_parquet && !is_csv {
@@ -785,6 +834,7 @@ impl PyGraph {
     ///     layer_col (str, optional): The edge layer column name in a dataframe. Cannot be used in combination with layer. Defaults to None.
     ///     schema (list[tuple[str, DataType | PropType | str]] | dict[str, DataType | PropType | str], optional): A list of (column_name, column_type) tuples or dict of {"column_name": column_type} to cast columns to. Defaults to None.
     ///     csv_options (dict[str, str | bool], optional): A dictionary of CSV reading options such as delimiter, comment, escape, quote, and terminator characters, as well as allow_truncated_rows and has_header flags. Defaults to None.
+    ///     event_id (str, optional): The column name for the secondary index. Defaults to None.
     ///
     /// Returns:
     ///     None: This function does not return a value if the operation is successful.
@@ -792,7 +842,7 @@ impl PyGraph {
     /// Raises:
     ///     GraphError: If the operation fails.
     #[pyo3(
-        signature = (data, time, src, dst, properties = None, metadata = None, shared_metadata = None, layer = None, layer_col = None, schema = None, csv_options = None)
+        signature = (data, time, src, dst, properties = None, metadata = None, shared_metadata = None, layer = None, layer_col = None, schema = None, csv_options = None, event_id = None)
     )]
     fn load_edges(
         &self,
@@ -807,6 +857,7 @@ impl PyGraph {
         layer_col: Option<&str>,
         schema: Option<Bound<PyAny>>,
         csv_options: Option<CsvReadOptions>,
+        event_id: Option<&str>,
     ) -> Result<(), GraphError> {
         let properties = convert_py_prop_args(properties.as_deref()).unwrap_or_default();
         let metadata = convert_py_prop_args(metadata.as_deref()).unwrap_or_default();
@@ -824,6 +875,7 @@ impl PyGraph {
                 layer,
                 layer_col,
                 column_schema,
+                event_id,
             )
         } else if let Ok(path) = data.extract::<PathBuf>() {
             // extracting PathBuf handles Strings too
@@ -846,14 +898,12 @@ impl PyGraph {
                 load_edges_from_parquet(
                     &self.graph,
                     &path,
-                    time,
-                    src,
-                    dst,
+                    ColumnNames::new(time, event_id, src, dst, layer_col),
+                    true,
                     &properties,
                     &metadata,
                     shared_metadata.as_ref(),
                     layer,
-                    layer_col,
                     None,
                     arced_schema.clone(),
                 )?;
@@ -872,6 +922,7 @@ impl PyGraph {
                     layer_col,
                     csv_options.as_ref(),
                     arced_schema.clone(),
+                    event_id,
                 )?;
             }
             if !is_parquet && !is_csv {
@@ -954,6 +1005,8 @@ impl PyGraph {
                     id,
                     node_type,
                     node_type_col,
+                    None,
+                    None,
                     &metadata,
                     shared_metadata.as_ref(),
                     None,
@@ -1061,6 +1114,7 @@ impl PyGraph {
                     layer_col,
                     None,
                     arced_schema.clone(),
+                    true,
                 )?;
             }
             if is_csv {
@@ -1090,6 +1144,7 @@ impl PyGraph {
     ///
     /// Returns:
     ///     None:
+    #[cfg(feature = "search")]
     fn create_index(&self) -> Result<(), GraphError> {
         self.graph.create_index()
     }
@@ -1101,6 +1156,7 @@ impl PyGraph {
     ///
     /// Returns:
     ///     None:
+    #[cfg(feature = "search")]
     fn create_index_with_spec(&self, py_spec: &PyIndexSpec) -> Result<(), GraphError> {
         self.graph.create_index_with_spec(py_spec.spec.clone())
     }
@@ -1112,6 +1168,7 @@ impl PyGraph {
     ///
     /// Returns:
     ///     None:
+    #[cfg(feature = "search")]
     fn create_index_in_ram(&self) -> Result<(), GraphError> {
         self.graph.create_index_in_ram()
     }
@@ -1129,6 +1186,7 @@ impl PyGraph {
     ///
     /// Returns:
     ///     None:
+    #[cfg(feature = "search")]
     fn create_index_in_ram_with_spec(&self, py_spec: &PyIndexSpec) -> Result<(), GraphError> {
         self.graph
             .create_index_in_ram_with_spec(py_spec.spec.clone())
diff --git a/raphtory/src/python/graph/graph_with_deletions.rs b/raphtory/src/python/graph/graph_with_deletions.rs
index af508b48cf..53c1ed0fd7 100644
--- a/raphtory/src/python/graph/graph_with_deletions.rs
+++ b/raphtory/src/python/graph/graph_with_deletions.rs
@@ -12,19 +12,19 @@ use crate::{
         graph::{edge::EdgeView, node::NodeView, views::deletion_graph::PersistentGraph},
     },
     errors::GraphError,
-    io::parquet_loaders::*,
-    prelude::{DeletionOps, GraphViewOps, ImportOps, IndexMutationOps},
+    io::{arrow::df_loaders::edges::ColumnNames, parquet_loaders::*},
+    prelude::{DeletionOps, GraphViewOps, ImportOps, ParquetEncoder},
     python::{
         graph::{
             edge::PyEdge,
-            index::PyIndexSpec,
             io::arrow_loaders::{
                 convert_py_prop_args, convert_py_schema, is_csv_path,
                 load_edge_deletions_from_arrow_c_stream, load_edge_deletions_from_csv_path,
                 load_edge_metadata_from_arrow_c_stream, load_edge_metadata_from_csv_path,
                 load_edges_from_arrow_c_stream, load_edges_from_csv_path,
-                load_node_metadata_from_arrow_c_stream, load_node_metadata_from_csv_path,
-                load_nodes_from_arrow_c_stream, load_nodes_from_csv_path, CsvReadOptions,
+                load_graph_props_from_arrow_c_stream, load_node_metadata_from_arrow_c_stream,
+                load_node_metadata_from_csv_path, load_nodes_from_arrow_c_stream,
+                load_nodes_from_csv_path, CsvReadOptions,
             },
             node::PyNode,
             views::graph_view::PyGraphView,
@@ -33,7 +33,7 @@ use crate::{
     },
     serialise::StableEncode,
 };
-use pyo3::{exceptions::PyValueError, prelude::*, pybacked::PyBackedStr};
+use pyo3::{exceptions::PyValueError, prelude::*, pybacked::PyBackedStr, Borrowed};
 use raphtory_api::{
     core::{
         entities::{properties::prop::Prop, GID},
@@ -49,7 +49,15 @@ use std::{
     sync::Arc,
 };
 
+use crate::python::config::PyConfig;
+#[cfg(feature = "search")]
+use crate::{prelude::IndexMutationOps, python::graph::index::PyIndexSpec};
+
 /// A temporal graph that allows edges and nodes to be deleted.
+///
+/// Arguments:
+///     path (str | PathLike, optional): The path for persisting the graph (only works with disk storage enabled). Defaults to None.
+///     config (Config, optional): Storage/config overrides. Defaults to None.
 #[derive(Clone)]
 #[pyclass(name = "PersistentGraph", extends = PyGraphView, frozen, module="raphtory")]
 pub struct PyPersistentGraph {
@@ -86,16 +94,18 @@ impl<'py> IntoPyObject<'py> for PersistentGraph {
     }
 }
 
-impl<'source> FromPyObject<'source> for PersistentGraph {
-    fn extract_bound(ob: &Bound<'source, PyAny>) -> PyResult<Self> {
-        let g = ob.downcast::<PyPersistentGraph>()?.get();
+impl<'py> FromPyObject<'_, 'py> for PersistentGraph {
+    type Error = PyErr;
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
+        let binding = ob.cast::<PyPersistentGraph>()?;
+        let g = binding.get();
         Ok(g.graph.clone())
     }
 }
 
 impl PyPersistentGraph {
     pub fn py_from_db_graph(db_graph: PersistentGraph) -> PyResult<Py<PyPersistentGraph>> {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             Py::new(
                 py,
                 (
@@ -108,27 +118,75 @@ impl PyPersistentGraph {
 }
 
 /// A temporal graph that allows edges and nodes to be deleted.
+///
+/// Arguments:
+///     path (str | PathLike, optional): the path to persist the graph (only works with disk storage enabled)
+///     config (Config, optional): the configuration options for the graph
 #[pymethods]
 impl PyPersistentGraph {
     #[new]
-    pub fn py_new() -> (Self, PyGraphView) {
-        let graph = PersistentGraph::new();
-        (
+    #[pyo3(signature = (path = None, config=None))]
+    pub fn py_new(
+        path: Option<PathBuf>,
+        config: Option<PyConfig>,
+    ) -> Result<(Self, PyGraphView), GraphError> {
+        let graph = match path {
+            Some(path) => match config {
+                None => PersistentGraph::new_at_path(&path)?,
+                Some(PyConfig(config)) => PersistentGraph::new_at_path_with_config(&path, config)?,
+            },
+            None => match config {
+                None => PersistentGraph::new(),
+                Some(PyConfig(config)) => PersistentGraph::new_with_config(config)?,
+            },
+        };
+        Ok((
             Self {
                 graph: graph.clone(),
             },
             PyGraphView::from(graph),
-        )
+        ))
+    }
+
+    /// Load a disk graph from path
+    ///
+    /// Arguments:
+    ///     path (str | PathLike): the path of the graph folder
+    ///     config (Config, optional): specify a new config to override the values saved for the graph
+    ///                                (note that the page sizes cannot be overridden and are ignored)
+    ///
+    /// Returns:
+    ///     PersistentGraph: the graph
+    #[staticmethod]
+    pub fn load(path: PathBuf, config: Option<PyConfig>) -> Result<PersistentGraph, GraphError> {
+        match config {
+            None => PersistentGraph::load(&path),
+            Some(PyConfig(config)) => PersistentGraph::load_with_config(&path, config),
+        }
+    }
+
+    /// Trigger a flush of the underlying storage if disk storage is enabled
+    ///
+    /// Returns:
+    ///     None: This function does not return a value, if the operation is successful.
+    pub fn flush(&self) -> Result<(), GraphError> {
+        self.graph.flush()
     }
 
-    #[cfg(feature = "storage")]
-    pub fn to_disk_graph(&self, graph_dir: PathBuf) -> Result<PersistentGraph, GraphError> {
-        self.graph.persist_as_disk_graph(graph_dir)
+    fn __reduce__(&self) -> Result<(PyGraphEncoder, (Vec<u8>,)), GraphError> {
+        let state = self.graph.encode_to_bytes()?;
+        Ok((PyGraphEncoder, (state,)))
     }
 
-    fn __reduce__(&self) -> (PyGraphEncoder, (Vec<u8>,)) {
-        let state = self.graph.encode_to_vec();
-        (PyGraphEncoder, (state,))
+    /// Persist graph to parquet files
+    ///
+    /// Arguments:
+    ///     graph_dir (str | PathLike): the folder where the graph will be persisted as parquet
+    ///
+    /// Returns:
+    ///     None:
+    pub fn to_parquet(&self, graph_dir: PathBuf) -> Result<(), GraphError> {
+        self.graph.encode_parquet(graph_dir)
     }
 
     /// Adds a new node with the given id and properties to the graph.
@@ -137,15 +195,16 @@ impl PyPersistentGraph {
     ///    timestamp (TimeInput): The timestamp of the node.
     ///    id (str | int): The id of the node.
     ///    properties (PropInput, optional): The properties of the node.
-    ///    node_type (str, optional) : The optional string which will be used as a node type.
+    ///    node_type (str, optional): The optional string which will be used as a node type.
     ///    event_id (int, optional): The optional integer which will be used as an event id.
+    ///    layer: (str, optional): The optional string which will be used as a layer.
     ///
     /// Returns:
     ///     None: This function does not return a value, if the operation is successful.
     ///
     /// Raises:
     ///     GraphError: If the operation fails.
-    #[pyo3(signature = (timestamp, id, properties = None, node_type = None, event_id = None))]
+    #[pyo3(signature = (timestamp, id, properties = None, node_type = None, event_id = None, layer = None))]
     pub fn add_node(
         &self,
         timestamp: EventTimeComponent,
@@ -153,16 +212,22 @@ impl PyPersistentGraph {
         properties: Option<HashMap<String, Prop>>,
         node_type: Option<&str>,
         event_id: Option<usize>,
+        layer: Option<&str>,
     ) -> Result<NodeView<'static, PersistentGraph>, GraphError> {
         match event_id {
-            None => self
-                .graph
-                .add_node(timestamp, id, properties.unwrap_or_default(), node_type),
+            None => self.graph.add_node(
+                timestamp,
+                id,
+                properties.unwrap_or_default(),
+                node_type,
+                layer,
+            ),
             Some(event_id) => self.graph.add_node(
                 (timestamp, event_id),
                 id,
                 properties.unwrap_or_default(),
                 node_type,
+                layer,
             ),
         }
     }
@@ -173,15 +238,16 @@ impl PyPersistentGraph {
     ///    timestamp (TimeInput): The timestamp of the node.
     ///    id (str | int): The id of the node.
     ///    properties (PropInput, optional): The properties of the node.
-    ///    node_type (str, optional) : The optional string which will be used as a node type.
+    ///    node_type (str, optional): The optional string which will be used as a node type.
     ///    event_id (int, optional): The optional integer which will be used as an event id.
+    ///    layer (str, optional): The optional string which will be used as a layer.
     ///
     /// Returns:
     ///   MutableNode: the newly created node.
     ///
     /// Raises:
     ///     GraphError: If the operation fails.
-    #[pyo3(signature = (timestamp, id, properties = None, node_type = None, event_id = None))]
+    #[pyo3(signature = (timestamp, id, properties = None, node_type = None, event_id = None, layer = None))]
     pub fn create_node(
         &self,
         timestamp: EventTimeComponent,
@@ -189,17 +255,22 @@ impl PyPersistentGraph {
         properties: Option<HashMap<String, Prop>>,
         node_type: Option<&str>,
         event_id: Option<usize>,
+        layer: Option<&str>,
     ) -> Result<NodeView<'static, PersistentGraph>, GraphError> {
         match event_id {
-            None => {
-                self.graph
-                    .create_node(timestamp, id, properties.unwrap_or_default(), node_type)
-            }
+            None => self.graph.create_node(
+                timestamp,
+                id,
+                properties.unwrap_or_default(),
+                node_type,
+                layer,
+            ),
             Some(event_id) => self.graph.create_node(
                 (timestamp, event_id),
                 id,
                 properties.unwrap_or_default(),
                 node_type,
+                layer,
             ),
         }
     }
@@ -565,7 +636,7 @@ impl PyPersistentGraph {
     ///
     /// Returns:
     ///     PersistentGraph: the graph with persistent semantics applied
-    pub fn persistent_graph<'py>(&'py self) -> PyResult<Py<PyPersistentGraph>> {
+    pub fn persistent_graph(&self) -> PyResult<Py<PyPersistentGraph>> {
         PyPersistentGraph::py_from_db_graph(self.graph.persistent_graph())
     }
 
@@ -585,6 +656,9 @@ impl PyPersistentGraph {
     ///     shared_metadata (PropInput, optional): A dictionary of metadata properties that will be added to every node. Defaults to None.
     ///     schema (list[tuple[str, DataType | PropType | str]] | dict[str, DataType | PropType | str], optional): A list of (column_name, column_type) tuples or dict of {"column_name": column_type} to cast columns to. Defaults to None.
     ///     csv_options (dict[str, str | bool], optional): A dictionary of CSV reading options such as delimiter, comment, escape, quote, and terminator characters, as well as allow_truncated_rows and has_header flags. Defaults to None.
+    ///     event_id (str, optional): The column name for the secondary index.
+    ///     layer (str, optional): A value to use as the layer for all nodes. Cannot be used in combination with layer_col. Defaults to None.
+    ///     layer_col (str, optional): The node layer column name in a dataframe. Cannot be used in combination with layer. Defaults to None.
     ///
     /// Returns:
     ///     None: This function does not return a value if the operation is successful.
@@ -592,7 +666,7 @@ impl PyPersistentGraph {
     /// Raises:
     ///     GraphError: If the operation fails.
     #[pyo3(
-        signature = (data, time, id, node_type = None, node_type_col = None, properties = None, metadata= None, shared_metadata = None, schema = None, csv_options = None)
+        signature = (data, time, id, node_type = None, node_type_col = None, properties = None, metadata= None, shared_metadata = None, schema = None, csv_options = None, event_id = None, layer = None, layer_col = None)
     )]
     fn load_nodes(
         &self,
@@ -606,6 +680,9 @@ impl PyPersistentGraph {
         shared_metadata: Option<HashMap<String, Prop>>,
         schema: Option<Bound<PyAny>>,
         csv_options: Option<CsvReadOptions>,
+        event_id: Option<&str>,
+        layer: Option<&str>,
+        layer_col: Option<&str>,
     ) -> Result<(), GraphError> {
         let properties = convert_py_prop_args(properties.as_deref()).unwrap_or_default();
         let metadata = convert_py_prop_args(metadata.as_deref()).unwrap_or_default();
@@ -621,7 +698,10 @@ impl PyPersistentGraph {
                 &properties,
                 &metadata,
                 shared_metadata.as_ref(),
+                layer,
+                layer_col,
                 column_schema,
+                event_id,
             )
         } else if let Ok(path) = data.extract::<PathBuf>() {
             // extracting PathBuf handles Strings too
@@ -645,13 +725,17 @@ impl PyPersistentGraph {
                     &self.graph,
                     path.as_path(),
                     time,
+                    event_id,
                     id,
                     node_type,
                     node_type_col,
                     &properties,
                     &metadata,
                     shared_metadata.as_ref(),
+                    layer,
+                    layer_col,
                     None,
+                    true,
                     arced_schema.clone(),
                 )?;
             }
@@ -666,8 +750,11 @@ impl PyPersistentGraph {
                     &properties,
                     &metadata,
                     shared_metadata.as_ref(),
+                    layer,
+                    layer_col,
                     csv_options.as_ref(),
                     arced_schema,
+                    event_id,
                 )?;
             }
             if !is_parquet && !is_csv {
@@ -696,6 +783,7 @@ impl PyPersistentGraph {
     ///     layer_col (str, optional): The edge layer column name in a dataframe. Cannot be used in combination with layer. Defaults to None.
     ///     schema (list[tuple[str, DataType | PropType | str]] | dict[str, DataType | PropType | str], optional): A list of (column_name, column_type) tuples or dict of {"column_name": column_type} to cast columns to. Defaults to None.
     ///     csv_options (dict[str, str | bool], optional): A dictionary of CSV reading options such as delimiter, comment, escape, quote, and terminator characters, as well as allow_truncated_rows and has_header flags. Defaults to None.
+    ///     event_id (str, optional): The column name for the secondary index.
     ///
     /// Returns:
     ///     None: This function does not return a value if the operation is successful.
@@ -703,7 +791,7 @@ impl PyPersistentGraph {
     /// Raises:
     ///     GraphError: If the operation fails.
     #[pyo3(
-        signature = (data, time, src, dst, properties = None, metadata = None, shared_metadata = None, layer = None, layer_col = None, schema = None, csv_options = None)
+        signature = (data, time, src, dst, properties = None, metadata = None, shared_metadata = None, layer = None, layer_col = None, schema = None, csv_options = None, event_id = None)
     )]
     fn load_edges(
         &self,
@@ -711,6 +799,7 @@ impl PyPersistentGraph {
         time: &str,
         src: &str,
         dst: &str,
+
         properties: Option<Vec<PyBackedStr>>,
         metadata: Option<Vec<PyBackedStr>>,
         shared_metadata: Option<HashMap<String, Prop>>,
@@ -718,6 +807,7 @@ impl PyPersistentGraph {
         layer_col: Option<&str>,
         schema: Option<Bound<PyAny>>,
         csv_options: Option<CsvReadOptions>,
+        event_id: Option<&str>,
     ) -> Result<(), GraphError> {
         let properties = convert_py_prop_args(properties.as_deref()).unwrap_or_default();
         let metadata = convert_py_prop_args(metadata.as_deref()).unwrap_or_default();
@@ -735,6 +825,7 @@ impl PyPersistentGraph {
                 layer,
                 layer_col,
                 column_schema,
+                event_id,
             )
         } else if let Ok(path) = data.extract::<PathBuf>() {
             // extracting PathBuf handles Strings too
@@ -757,14 +848,12 @@ impl PyPersistentGraph {
                 load_edges_from_parquet(
                     &self.graph,
                     &path,
-                    time,
-                    src,
-                    dst,
+                    ColumnNames::new(time, event_id, src, dst, layer_col),
+                    true,
                     &properties,
                     &metadata,
                     shared_metadata.as_ref(),
                     layer,
-                    layer_col,
                     None,
                     arced_schema.clone(),
                 )?;
@@ -783,6 +872,7 @@ impl PyPersistentGraph {
                     layer_col,
                     csv_options.as_ref(),
                     arced_schema.clone(),
+                    event_id,
                 )?;
             }
             if !is_parquet && !is_csv {
@@ -808,23 +898,26 @@ impl PyPersistentGraph {
     ///     layer_col (str, optional): The edge layer col name in the data source. Cannot be used in combination with layer. Defaults to None.
     ///     schema (list[tuple[str, DataType | PropType | str]] | dict[str, DataType | PropType | str], optional): A list of (column_name, column_type) tuples or dict of {"column_name": column_type} to cast columns to. Defaults to None.
     ///     csv_options (dict[str, str | bool], optional): A dictionary of CSV reading options such as delimiter, comment, escape, quote, and terminator characters, as well as allow_truncated_rows and has_header flags. Defaults to None.
+    ///     event_id (str, optional): The column name for the secondary index.
     ///
     /// Returns:
     ///     None: This function does not return a value, if the operation is successful.
     ///
     /// Raises:
     ///     GraphError: If the operation fails.
-    #[pyo3(signature = (data, time, src, dst, layer = None, layer_col = None, schema = None, csv_options = None))]
+    #[pyo3(signature = (data, time, src, dst, layer = None, layer_col = None, schema = None, csv_options = None, event_id = None))]
     fn load_edge_deletions(
         &self,
         data: &Bound<PyAny>,
         time: &str,
         src: &str,
         dst: &str,
+
         layer: Option<&str>,
         layer_col: Option<&str>,
         schema: Option<Bound<PyAny>>,
         csv_options: Option<CsvReadOptions>,
+        event_id: Option<&str>,
     ) -> Result<(), GraphError> {
         let column_schema = convert_py_schema(schema)?;
         if data.hasattr("__arrow_c_stream__")? {
@@ -832,6 +925,7 @@ impl PyPersistentGraph {
                 &self.graph,
                 data,
                 time,
+                event_id,
                 src,
                 dst,
                 layer,
@@ -859,11 +953,9 @@ impl PyPersistentGraph {
                 load_edge_deletions_from_parquet(
                     &self.graph,
                     path.as_path(),
-                    time,
-                    src,
-                    dst,
+                    ColumnNames::new(time, event_id, src, dst, layer_col),
                     layer,
-                    layer_col,
+                    true,
                     None,
                     arced_schema.clone(),
                 )?;
@@ -879,6 +971,7 @@ impl PyPersistentGraph {
                     layer_col,
                     csv_options.as_ref(),
                     arced_schema,
+                    event_id,
                 )?;
             }
             if !is_parquet && !is_csv {
@@ -961,6 +1054,8 @@ impl PyPersistentGraph {
                     id,
                     node_type,
                     node_type_col,
+                    None,
+                    None,
                     &metadata,
                     shared_metadata.as_ref(),
                     None,
@@ -1068,6 +1163,7 @@ impl PyPersistentGraph {
                     layer_col,
                     None,
                     arced_schema.clone(),
+                    true,
                 )?;
             }
             if is_csv {
@@ -1093,10 +1189,81 @@ impl PyPersistentGraph {
         }
     }
 
+    /// Load graph properties from any data source that supports the ArrowStreamExportable protocol (by providing an __arrow_c_stream__() method),
+    /// or a path to a Parquet file, or a directory containing multiple Parquet files.
+    /// The following are known to support the ArrowStreamExportable protocol: Pandas dataframes, FireDucks(.pandas) dataframes,
+    /// Polars dataframes, Arrow tables, DuckDB (e.g. DuckDBPyRelation obtained from running an SQL query).
+    ///
+    /// Arguments:
+    ///     data (Any): The data source containing graph properties.
+    ///     time (str): The column name for the update timestamps.
+    ///     properties (List[str], optional): List of temporal property column names. Defaults to None.
+    ///     metadata (List[str], optional): List of constant property column names. Defaults to None.
+    ///     schema (list[tuple[str, DataType | PropType | str]] | dict[str, DataType | PropType | str], optional): A list of (column_name, column_type) tuples or dict of {"column_name": column_type} to cast columns to. Defaults to None.
+    ///     event_id (str, optional): The column name for the secondary index.
+    ///
+    /// Returns:
+    ///     None: This function does not return a value if the operation is successful.
+    ///
+    /// Raises:
+    ///     GraphError: If the operation fails.
+    #[pyo3(
+        signature = (data, time, properties = None, metadata = None, schema = None, event_id = None)
+    )]
+    fn load_graph_properties(
+        &self,
+        data: &Bound<PyAny>,
+        time: &str,
+        properties: Option<Vec<PyBackedStr>>,
+        metadata: Option<Vec<PyBackedStr>>,
+        schema: Option<Bound<PyAny>>,
+        event_id: Option<&str>,
+    ) -> Result<(), GraphError> {
+        let properties = convert_py_prop_args(properties.as_deref()).unwrap_or_default();
+        let metadata = convert_py_prop_args(metadata.as_deref()).unwrap_or_default();
+        let column_schema = convert_py_schema(schema)?;
+        if data.hasattr("__arrow_c_stream__")? {
+            load_graph_props_from_arrow_c_stream(
+                &self.graph,
+                data,
+                time,
+                event_id,
+                Some(&properties),
+                Some(&metadata),
+                column_schema,
+            )
+        } else if let Ok(path) = data.extract::<PathBuf>() {
+            // extracting PathBuf handles Strings too
+            let is_parquet = is_parquet_path(&path)?;
+
+            // wrap in Arc to avoid cloning the entire schema for Parquet and inner loops
+            let arced_schema = column_schema.map(Arc::new);
+
+            if is_parquet {
+                load_graph_props_from_parquet(
+                    &self.graph,
+                    path.as_path(),
+                    time,
+                    event_id,
+                    &properties,
+                    &metadata,
+                    None,
+                    arced_schema,
+                )?;
+            } else {
+                return Err(GraphError::PythonError(PyValueError::new_err("Argument 'data' contains invalid path. Paths must either point to a Parquet file, or a directory containing Parquet files")));
+            }
+            Ok(())
+        } else {
+            Err(GraphError::PythonError(PyValueError::new_err("Argument 'data' invalid. Valid data sources are: a single Parquet file, a directory containing Parquet files, and objects that implement an __arrow_c_stream__ method.")))
+        }
+    }
+
     /// Create graph index
     ///
     /// Returns:
     ///     None:
+    #[cfg(feature = "search")]
     fn create_index(&self) -> Result<(), GraphError> {
         self.graph.create_index()
     }
@@ -1107,6 +1274,7 @@ impl PyPersistentGraph {
     ///
     /// Returns:
     ///     None:
+    #[cfg(feature = "search")]
     fn create_index_with_spec(&self, py_spec: &PyIndexSpec) -> Result<(), GraphError> {
         self.graph.create_index_with_spec(py_spec.spec.clone())
     }
@@ -1118,6 +1286,7 @@ impl PyPersistentGraph {
     ///
     /// Returns:
     ///     None:
+    #[cfg(feature = "search")]
     fn create_index_in_ram(&self) -> Result<(), GraphError> {
         self.graph.create_index_in_ram()
     }
@@ -1135,6 +1304,7 @@ impl PyPersistentGraph {
     ///
     /// Returns:
     ///     None:
+    #[cfg(feature = "search")]
     fn create_index_in_ram_with_spec(&self, py_spec: &PyIndexSpec) -> Result<(), GraphError> {
         self.graph
             .create_index_in_ram_with_spec(py_spec.spec.clone())
diff --git a/raphtory/src/python/graph/history.rs b/raphtory/src/python/graph/history.rs
index fa5db3aea8..aef1cea89a 100644
--- a/raphtory/src/python/graph/history.rs
+++ b/raphtory/src/python/graph/history.rs
@@ -231,7 +231,7 @@ impl PyHistory {
     /// Returns:
     ///     bool: True if equal, otherwise False.
     fn __eq__(&self, other: &Bound<PyAny>) -> bool {
-        if let Ok(py_hist) = other.downcast::<PyHistory>() {
+        if let Ok(py_hist) = other.cast::<PyHistory>() {
             return self.history.eq(&py_hist.get().history);
         }
         // compare timestamps only
@@ -295,9 +295,10 @@ impl<'py, T: IntoArcDynHistoryOps> IntoPyObject<'py> for History<'_, T> {
     }
 }
 
-impl<'py> FromPyObject<'py> for History<'static, Arc<dyn InternalHistoryOps>> {
-    fn extract_bound(ob: &Bound<'_, PyAny>) -> PyResult<Self> {
-        let py_history = ob.downcast::<PyHistory>()?;
+impl<'py> FromPyObject<'_, 'py> for History<'static, Arc<dyn InternalHistoryOps>> {
+    type Error = PyErr;
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
+        let py_history = ob.cast::<PyHistory>()?;
         Ok(py_history.get().history.clone())
     }
 }
@@ -397,7 +398,7 @@ impl PyHistoryTimestamp {
     /// Returns:
     ///     bool: True if equal, otherwise False.
     fn __eq__(&self, other: &Bound<PyAny>) -> bool {
-        if let Ok(py_hist) = other.downcast::<PyHistoryTimestamp>() {
+        if let Ok(py_hist) = other.cast::<PyHistoryTimestamp>() {
             return self.history_t.iter().eq(py_hist.get().history_t.iter());
         }
         if let Ok(list) = other.extract::<Vec<i64>>() {
@@ -583,7 +584,7 @@ impl PyHistoryDateTime {
             }
             None
         };
-        if let Ok(py_hist) = other.downcast::<PyHistoryDateTime>() {
+        if let Ok(py_hist) = other.cast::<PyHistoryDateTime>() {
             return self.history_dt.iter().eq(py_hist.get().history_dt.iter());
         }
         if let Some(iterator) = dt_iter_opt {
@@ -746,7 +747,7 @@ impl PyHistoryEventId {
     /// Returns:
     ///     bool: True if equal, otherwise False.
     fn __eq__(&self, other: &Bound<PyAny>) -> bool {
-        if let Ok(py_hist) = other.downcast::<PyHistoryEventId>() {
+        if let Ok(py_hist) = other.cast::<PyHistoryEventId>() {
             return self.history_s.iter().eq(py_hist.get().history_s.iter());
         }
         if let Ok(list) = other.extract::<Vec<usize>>() {
@@ -909,7 +910,7 @@ impl PyIntervals {
     /// Returns:
     ///     bool: True if equal, otherwise False.
     fn __eq__(&self, other: &Bound<PyAny>) -> bool {
-        if let Ok(py_hist) = other.downcast::<PyIntervals>() {
+        if let Ok(py_hist) = other.cast::<PyIntervals>() {
             return self.intervals.iter().eq(py_hist.get().intervals.iter());
         }
         if let Ok(list) = other.extract::<Vec<i64>>() {
diff --git a/raphtory/src/python/graph/io/arrow_loaders.rs b/raphtory/src/python/graph/io/arrow_loaders.rs
index af0c3208cb..b20c8d6290 100644
--- a/raphtory/src/python/graph/io/arrow_loaders.rs
+++ b/raphtory/src/python/graph/io/arrow_loaders.rs
@@ -5,14 +5,15 @@ use crate::{
         arrow::{
             dataframe::{DFChunk, DFView},
             df_loaders::{
-                load_edge_deletions_from_df, load_edges_from_df, load_edges_props_from_df,
-                load_node_props_from_df, load_nodes_from_df,
+                edges::{load_edges_from_df_prefetch, ColumnNames},
+                load_edge_deletions_from_df_prefetch, load_edges_props_from_df_prefetch,
+                load_graph_props_from_df,
+                nodes::{load_node_props_from_df, load_nodes_from_df},
             },
         },
         parquet_loaders::cast_columns,
     },
     prelude::{AdditionOps, PropertyAdditionOps},
-    serialise::incremental::InternalCache,
 };
 use arrow::{
     array::{RecordBatch, RecordBatchReader},
@@ -22,11 +23,7 @@ use arrow_csv::{reader::Format, ReaderBuilder};
 use bzip2::read::BzDecoder;
 use flate2::read::GzDecoder;
 use pyo3::{
-    exceptions::PyValueError,
-    ffi::c_str,
-    prelude::*,
-    pybacked::PyBackedStr,
-    types::{PyCapsule, PyDict},
+    exceptions::PyValueError, ffi::c_str, prelude::*, pybacked::PyBackedStr, types::PyDict,
 };
 use pyo3_arrow::PyRecordBatchReader;
 use raphtory_api::core::entities::properties::prop::{Prop, PropType};
@@ -40,6 +37,7 @@ use std::{
     path::{Path, PathBuf},
     sync::Arc,
 };
+use storage::utils::Iter3;
 use tracing::error;
 
 const CHUNK_SIZE: usize = 1_000_000; // split large chunks so progress bar updates reasonably
@@ -64,7 +62,7 @@ pub(crate) fn convert_py_schema(
 
 pub(crate) fn load_nodes_from_arrow_c_stream<
     'py,
-    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps + InternalCache,
+    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps + std::fmt::Debug,
 >(
     graph: &G,
     data: &Bound<'py, PyAny>,
@@ -75,32 +73,44 @@ pub(crate) fn load_nodes_from_arrow_c_stream<
     properties: &[&str],
     metadata: &[&str],
     shared_metadata: Option<&HashMap<String, Prop>>,
+    layer: Option<&str>,
+    layer_col: Option<&str>,
     schema: Option<HashMap<String, PropType>>,
+    event_id: Option<&str>,
 ) -> Result<(), GraphError> {
-    let mut cols_to_check = vec![id, time];
-    cols_to_check.extend_from_slice(properties);
-    cols_to_check.extend_from_slice(metadata);
-    if let Some(ref node_type_col) = node_type_col {
-        cols_to_check.push(node_type_col.as_ref());
-    }
-    let df_view = process_arrow_c_stream_df(data, cols_to_check.clone(), schema)?;
+    let cols_to_check = [id, time]
+        .into_iter()
+        .chain(properties.iter().copied())
+        .chain(metadata.iter().copied())
+        .chain(node_type_col)
+        .chain(layer_col)
+        .chain(event_id)
+        .collect::<Vec<_>>();
+
+    let df_view = process_arrow_c_stream_df(data, &cols_to_check, schema)?;
     df_view.check_cols_exist(&cols_to_check)?;
-    load_nodes_from_df(
-        df_view,
-        time,
-        id,
-        properties,
-        metadata,
-        shared_metadata,
-        node_type,
-        node_type_col,
-        graph,
-    )
+    data.py().detach(|| {
+        load_nodes_from_df(
+            df_view,
+            time,
+            event_id,
+            id,
+            properties,
+            metadata,
+            shared_metadata,
+            node_type,
+            node_type_col,
+            graph,
+            true,
+            layer,
+            layer_col,
+        )
+    })
 }
 
 pub(crate) fn load_edges_from_arrow_c_stream<
     'py,
-    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps + InternalCache,
+    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps,
 >(
     graph: &G,
     data: &Bound<'py, PyAny>,
@@ -113,32 +123,36 @@ pub(crate) fn load_edges_from_arrow_c_stream<
     layer: Option<&str>,
     layer_col: Option<&str>,
     schema: Option<HashMap<String, PropType>>,
+    event_id: Option<&str>,
 ) -> Result<(), GraphError> {
-    let mut cols_to_check = vec![src, dst, time];
-    cols_to_check.extend_from_slice(properties);
-    cols_to_check.extend_from_slice(metadata);
-    if let Some(layer_col) = layer_col {
-        cols_to_check.push(layer_col.as_ref());
-    }
-    let df_view = process_arrow_c_stream_df(data, cols_to_check.clone(), schema)?;
+    let cols_to_check = [src, dst, time]
+        .into_iter()
+        .chain(properties.iter().copied())
+        .chain(metadata.iter().copied())
+        .chain(layer_col)
+        .chain(event_id)
+        .collect::<Vec<_>>();
+
+    let df_view = process_arrow_c_stream_df(data, &cols_to_check, schema)?;
     df_view.check_cols_exist(&cols_to_check)?;
-    load_edges_from_df(
-        df_view,
-        time,
-        src,
-        dst,
-        properties,
-        metadata,
-        shared_metadata,
-        layer,
-        layer_col,
-        graph,
-    )
+    data.py().detach(|| {
+        load_edges_from_df_prefetch(
+            df_view,
+            ColumnNames::new(time, event_id, src, dst, layer_col),
+            true,
+            properties,
+            metadata,
+            shared_metadata,
+            layer,
+            graph,
+            false,
+        )
+    })
 }
 
 pub(crate) fn load_node_metadata_from_arrow_c_stream<
     'py,
-    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps + InternalCache,
+    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps + std::fmt::Debug,
 >(
     graph: &G,
     data: &Bound<'py, PyAny>,
@@ -149,27 +163,32 @@ pub(crate) fn load_node_metadata_from_arrow_c_stream<
     shared_metadata: Option<&HashMap<String, Prop>>,
     schema: Option<HashMap<String, PropType>>,
 ) -> Result<(), GraphError> {
-    let mut cols_to_check = vec![id];
-    cols_to_check.extend_from_slice(metadata);
-    if let Some(ref node_type_col) = node_type_col {
-        cols_to_check.push(node_type_col.as_ref());
-    }
-    let df_view = process_arrow_c_stream_df(data, cols_to_check.clone(), schema)?;
+    let cols_to_check = [id]
+        .into_iter()
+        .chain(metadata.iter().copied())
+        .chain(node_type_col)
+        .collect::<Vec<_>>();
+
+    let df_view = process_arrow_c_stream_df(data, &cols_to_check, schema)?;
     df_view.check_cols_exist(&cols_to_check)?;
-    load_node_props_from_df(
-        df_view,
-        id,
-        node_type,
-        node_type_col,
-        metadata,
-        shared_metadata,
-        graph,
-    )
+    data.py().detach(|| {
+        load_node_props_from_df(
+            df_view,
+            id,
+            node_type,
+            node_type_col,
+            None,
+            None,
+            metadata,
+            shared_metadata,
+            graph,
+        )
+    })
 }
 
 pub(crate) fn load_edge_metadata_from_arrow_c_stream<
     'py,
-    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps + InternalCache,
+    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps,
 >(
     graph: &G,
     data: &Bound<'py, PyAny>,
@@ -181,23 +200,26 @@ pub(crate) fn load_edge_metadata_from_arrow_c_stream<
     layer_col: Option<&str>,
     schema: Option<HashMap<String, PropType>>,
 ) -> Result<(), GraphError> {
-    let mut cols_to_check = vec![src, dst];
-    if let Some(ref layer_col) = layer_col {
-        cols_to_check.push(layer_col.as_ref());
-    }
-    cols_to_check.extend_from_slice(metadata);
-    let df_view = process_arrow_c_stream_df(data, cols_to_check.clone(), schema)?;
+    let cols_to_check = [src, dst]
+        .into_iter()
+        .chain(layer_col)
+        .chain(metadata.iter().copied())
+        .collect::<Vec<_>>();
+    let df_view = process_arrow_c_stream_df(data, &cols_to_check, schema)?;
     df_view.check_cols_exist(&cols_to_check)?;
-    load_edges_props_from_df(
-        df_view,
-        src,
-        dst,
-        metadata,
-        shared_metadata,
-        layer,
-        layer_col,
-        graph,
-    )
+    data.py().detach(|| {
+        load_edges_props_from_df_prefetch(
+            df_view,
+            src,
+            dst,
+            metadata,
+            shared_metadata,
+            layer,
+            layer_col,
+            graph,
+            true,
+        )
+    })
 }
 
 pub(crate) fn load_edge_deletions_from_arrow_c_stream<
@@ -207,67 +229,73 @@ pub(crate) fn load_edge_deletions_from_arrow_c_stream<
     graph: &G,
     data: &Bound<'py, PyAny>,
     time: &str,
+    event_id: Option<&str>,
     src: &str,
     dst: &str,
     layer: Option<&str>,
     layer_col: Option<&str>,
     schema: Option<HashMap<String, PropType>>,
 ) -> Result<(), GraphError> {
-    let mut cols_to_check = vec![src, dst, time];
-    if let Some(ref layer_col) = layer_col {
-        cols_to_check.push(layer_col.as_ref());
-    }
+    let cols_to_check = [src, dst, time]
+        .into_iter()
+        .chain(layer_col)
+        .chain(event_id)
+        .collect::<Vec<_>>();
+    let df_view = process_arrow_c_stream_df(data, &cols_to_check, schema)?;
+    df_view.check_cols_exist(&cols_to_check)?;
+    data.py().detach(|| {
+        load_edge_deletions_from_df_prefetch(
+            df_view,
+            ColumnNames::new(time, event_id, src, dst, layer_col),
+            true,
+            layer,
+            graph.core_graph(),
+        )
+    })
+}
 
-    let df_view = process_arrow_c_stream_df(data, cols_to_check.clone(), schema)?;
+pub(crate) fn load_graph_props_from_arrow_c_stream<
+    'py,
+    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps,
+>(
+    graph: &G,
+    data: &Bound<'py, PyAny>,
+    time: &str,
+    secondary_index: Option<&str>,
+    properties: Option<&[&str]>,
+    metadata: Option<&[&str]>,
+    schema: Option<HashMap<String, PropType>>,
+) -> Result<(), GraphError> {
+    let cols_to_check = [time]
+        .into_iter()
+        .chain(secondary_index)
+        .chain(properties.unwrap_or(&[]).iter().copied())
+        .chain(metadata.unwrap_or(&[]).iter().copied())
+        .collect::<Vec<_>>();
+    let df_view = process_arrow_c_stream_df(data, &cols_to_check, schema)?;
     df_view.check_cols_exist(&cols_to_check)?;
-    load_edge_deletions_from_df(
-        df_view,
-        time,
-        src,
-        dst,
-        layer,
-        layer_col,
-        graph.core_graph(),
-    )
+    data.py().detach(|| {
+        load_graph_props_from_df(df_view, time, secondary_index, properties, metadata, graph)
+    })
 }
 
 /// Can handle any object that provides the \_\_arrow_c_stream__() interface
 pub(crate) fn process_arrow_c_stream_df<'a>(
     data: &Bound<'a, PyAny>,
-    col_names: Vec<&str>,
+    col_names: &[&str],
     schema: Option<HashMap<String, PropType>>,
 ) -> PyResult<DFView<impl Iterator<Item = Result<DFChunk, GraphError>> + 'a>> {
     let py = data.py();
     is_jupyter(py);
 
-    if !data.hasattr("__arrow_c_stream__")? {
-        return Err(PyErr::from(GraphError::LoadFailure(
-            "Object must implement __arrow_c_stream__".to_string(),
-        )));
-    }
-
-    let stream_capsule_any: Bound<'a, PyAny> = data.call_method0("__arrow_c_stream__")?;
-    let stream_capsule: &Bound<'a, PyCapsule> = stream_capsule_any.downcast::<PyCapsule>()?;
+    let reader: PyRecordBatchReader = data.extract()?;
 
-    if !stream_capsule.is_valid() {
-        return Err(PyErr::from(GraphError::LoadFailure(
-            "Stream capsule is not valid".to_string(),
-        )));
-    }
-    let reader = PyRecordBatchReader::from_arrow_pycapsule(stream_capsule)
-        .map_err(|e| {
-            PyErr::from(GraphError::LoadFailure(format!(
-                "Arrow stream error while creating the reader: {}",
-                e
-            )))
-        })?
-        .into_reader()
-        .map_err(|e| {
-            PyErr::from(GraphError::LoadFailure(format!(
-                "Arrow stream error while creating the reader: {}",
-                e
-            )))
-        })?;
+    let reader = reader.into_reader().map_err(|e| {
+        PyErr::from(GraphError::LoadFailure(format!(
+            "Arrow stream error while creating the reader: {}",
+            e
+        )))
+    })?;
 
     // Get column names and indices once only
     let mut names: Vec<String> = Vec::with_capacity(col_names.len());
@@ -290,10 +318,7 @@ pub(crate) fn process_arrow_c_stream_df<'a>(
         .into_iter()
         .flat_map(move |batch_res: Result<RecordBatch, _>| {
             let batch: RecordBatch = match batch_res.map_err(|e| {
-                GraphError::LoadFailure(format!(
-                    "Arrow stream error while reading a batch: {}",
-                    e.to_string()
-                ))
+                GraphError::LoadFailure(format!("Arrow stream error while reading a batch: {}", e))
             }) {
                 Ok(batch) => batch,
                 Err(e) => return vec![Err(e)],
@@ -370,9 +395,11 @@ pub(crate) struct CsvReadOptions {
     has_header: Option<bool>,
 }
 
-impl<'a> FromPyObject<'a> for CsvReadOptions {
-    fn extract_bound(ob: &Bound<'a, PyAny>) -> PyResult<Self> {
-        let dict = ob.downcast::<PyDict>().map_err(|e| {
+impl<'py> FromPyObject<'_, 'py> for CsvReadOptions {
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
+        let dict = ob.cast::<PyDict>().map_err(|e| {
             PyValueError::new_err(format!("CSV options should be passed as a dict: {e}"))
         })?;
         let get_char = |option: &str| match dict.get_item(option)? {
@@ -440,7 +467,7 @@ fn collect_csv_paths(path: &PathBuf) -> Result<Vec<PathBuf>, GraphError> {
 // Load from CSV files using arrow-csv
 pub(crate) fn load_nodes_from_csv_path<
     'py,
-    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps + InternalCache,
+    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps + std::fmt::Debug,
 >(
     graph: &G,
     path: &PathBuf,
@@ -451,23 +478,29 @@ pub(crate) fn load_nodes_from_csv_path<
     properties: &[&str],
     metadata: &[&str],
     shared_metadata: Option<&HashMap<String, Prop>>,
+    layer: Option<&str>,
+    layer_col: Option<&str>,
     csv_options: Option<&CsvReadOptions>,
     schema: Option<Arc<HashMap<String, PropType>>>,
+    event_id: Option<&str>,
 ) -> Result<(), GraphError> {
-    let mut cols_to_check = vec![id, time];
-    cols_to_check.extend_from_slice(properties);
-    cols_to_check.extend_from_slice(metadata);
-    if let Some(ref node_type_col) = node_type_col {
-        cols_to_check.push(node_type_col.as_ref());
-    }
+    let cols_to_check = [id, time]
+        .into_iter()
+        .chain(properties.iter().copied())
+        .chain(metadata.iter().copied())
+        .chain(node_type_col)
+        .chain(layer_col)
+        .chain(event_id)
+        .collect::<Vec<_>>();
 
     let csv_paths = collect_csv_paths(path)?;
 
-    let df_view = process_csv_paths_df(&csv_paths, cols_to_check.clone(), csv_options, schema)?;
+    let df_view = process_csv_paths_df(&csv_paths, &cols_to_check, csv_options, schema)?;
     df_view.check_cols_exist(&cols_to_check)?;
     load_nodes_from_df(
         df_view,
         time,
+        event_id,
         id,
         properties,
         metadata,
@@ -475,12 +508,15 @@ pub(crate) fn load_nodes_from_csv_path<
         node_type,
         node_type_col,
         graph,
+        true,
+        layer,
+        layer_col,
     )
 }
 
 pub(crate) fn load_edges_from_csv_path<
     'py,
-    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps + InternalCache,
+    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps,
 >(
     graph: &G,
     path: &PathBuf,
@@ -494,35 +530,35 @@ pub(crate) fn load_edges_from_csv_path<
     layer_col: Option<&str>,
     csv_options: Option<&CsvReadOptions>,
     schema: Option<Arc<HashMap<String, PropType>>>,
+    event_id: Option<&str>,
 ) -> Result<(), GraphError> {
-    let mut cols_to_check = vec![src, dst, time];
-    cols_to_check.extend_from_slice(properties);
-    cols_to_check.extend_from_slice(metadata);
-    if let Some(layer_col) = layer_col {
-        cols_to_check.push(layer_col.as_ref());
-    }
+    let cols_to_check = [src, dst, time]
+        .into_iter()
+        .chain(properties.iter().copied())
+        .chain(metadata.iter().copied())
+        .chain(layer_col)
+        .collect::<Vec<_>>();
 
     let csv_paths = collect_csv_paths(path)?;
 
-    let df_view = process_csv_paths_df(&csv_paths, cols_to_check.clone(), csv_options, schema)?;
+    let df_view = process_csv_paths_df(&csv_paths, &cols_to_check, csv_options, schema)?;
     df_view.check_cols_exist(&cols_to_check)?;
-    load_edges_from_df(
+    load_edges_from_df_prefetch(
         df_view,
-        time,
-        src,
-        dst,
+        ColumnNames::new(time, event_id, src, dst, layer_col),
+        true,
         properties,
         metadata,
         shared_metadata,
         layer,
-        layer_col,
         graph,
+        false,
     )
 }
 
 pub(crate) fn load_node_metadata_from_csv_path<
     'py,
-    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps + InternalCache,
+    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps + std::fmt::Debug,
 >(
     graph: &G,
     path: &PathBuf,
@@ -534,21 +570,23 @@ pub(crate) fn load_node_metadata_from_csv_path<
     csv_options: Option<&CsvReadOptions>,
     schema: Option<Arc<HashMap<String, PropType>>>,
 ) -> Result<(), GraphError> {
-    let mut cols_to_check = vec![id];
-    cols_to_check.extend_from_slice(metadata);
-    if let Some(ref node_type_col) = node_type_col {
-        cols_to_check.push(node_type_col.as_ref());
-    }
+    let cols_to_check = [id]
+        .into_iter()
+        .chain(metadata.iter().copied())
+        .chain(node_type_col)
+        .collect::<Vec<_>>();
 
     let csv_paths = collect_csv_paths(path)?;
 
-    let df_view = process_csv_paths_df(&csv_paths, cols_to_check.clone(), csv_options, schema)?;
+    let df_view = process_csv_paths_df(&csv_paths, &cols_to_check, csv_options, schema)?;
     df_view.check_cols_exist(&cols_to_check)?;
     load_node_props_from_df(
         df_view,
         id,
         node_type,
         node_type_col,
+        None,
+        None,
         metadata,
         shared_metadata,
         graph,
@@ -557,7 +595,7 @@ pub(crate) fn load_node_metadata_from_csv_path<
 
 pub(crate) fn load_edge_metadata_from_csv_path<
     'py,
-    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps + InternalCache,
+    G: StaticGraphViewOps + PropertyAdditionOps + AdditionOps,
 >(
     graph: &G,
     path: &PathBuf,
@@ -570,17 +608,17 @@ pub(crate) fn load_edge_metadata_from_csv_path<
     csv_options: Option<&CsvReadOptions>,
     schema: Option<Arc<HashMap<String, PropType>>>,
 ) -> Result<(), GraphError> {
-    let mut cols_to_check = vec![src, dst];
-    if let Some(ref layer_col) = layer_col {
-        cols_to_check.push(layer_col.as_ref());
-    }
-    cols_to_check.extend_from_slice(metadata);
+    let cols_to_check = [src, dst]
+        .into_iter()
+        .chain(metadata.iter().copied())
+        .chain(layer_col)
+        .collect::<Vec<_>>();
 
     let csv_paths = collect_csv_paths(path)?;
 
-    let df_view = process_csv_paths_df(&csv_paths, cols_to_check.clone(), csv_options, schema)?;
+    let df_view = process_csv_paths_df(&csv_paths, &cols_to_check, csv_options, schema)?;
     df_view.check_cols_exist(&cols_to_check)?;
-    load_edges_props_from_df(
+    load_edges_props_from_df_prefetch(
         df_view,
         src,
         dst,
@@ -589,6 +627,7 @@ pub(crate) fn load_edge_metadata_from_csv_path<
         layer,
         layer_col,
         graph,
+        true,
     )
 }
 
@@ -605,28 +644,27 @@ pub(crate) fn load_edge_deletions_from_csv_path<
     layer_col: Option<&str>,
     csv_options: Option<&CsvReadOptions>,
     schema: Option<Arc<HashMap<String, PropType>>>,
+    event_id: Option<&str>,
 ) -> Result<(), GraphError> {
-    let mut cols_to_check = vec![src, dst, time];
-    if let Some(ref layer_col) = layer_col {
-        cols_to_check.push(layer_col.as_ref());
-    }
+    let cols_to_check = [src, dst, time]
+        .into_iter()
+        .chain(layer_col)
+        .collect::<Vec<_>>();
 
     let csv_paths = collect_csv_paths(path)?;
 
-    let df_view = process_csv_paths_df(&csv_paths, cols_to_check.clone(), csv_options, schema)?;
+    let df_view = process_csv_paths_df(&csv_paths, &cols_to_check, csv_options, schema)?;
     df_view.check_cols_exist(&cols_to_check)?;
-    load_edge_deletions_from_df(
+    load_edge_deletions_from_df_prefetch(
         df_view,
-        time,
-        src,
-        dst,
+        ColumnNames::new(time, event_id, src, dst, layer_col),
+        true,
         layer,
-        layer_col,
         graph.core_graph(),
     )
 }
 
-fn get_csv_reader(filename: &str, file: File) -> Box<dyn std::io::Read> {
+fn get_csv_reader(filename: &str, file: File) -> Box<dyn std::io::Read + Send> {
     // Support bz2 and gz compression
     if filename.ends_with(".csv.gz") {
         Box::new(GzDecoder::new(file))
@@ -641,7 +679,7 @@ fn get_csv_reader(filename: &str, file: File) -> Box<dyn std::io::Read> {
 fn build_csv_reader(
     path: &Path,
     csv_options: Option<&CsvReadOptions>,
-) -> Result<arrow_csv::reader::Reader<Box<dyn std::io::Read>>, GraphError> {
+) -> Result<arrow_csv::reader::Reader<Box<dyn std::io::Read + Send>>, GraphError> {
     let file = File::open(path)?;
     let path_str = path.to_string_lossy();
 
@@ -731,27 +769,27 @@ fn build_csv_reader(
 
 fn process_csv_paths_df<'a>(
     paths: &'a [PathBuf],
-    col_names: Vec<&'a str>,
+    col_names: &'a [&'a str],
     csv_options: Option<&'a CsvReadOptions>,
     schema: Option<Arc<HashMap<String, PropType>>>,
-) -> Result<DFView<impl Iterator<Item = Result<DFChunk, GraphError>> + 'a>, GraphError> {
+) -> Result<DFView<impl Iterator<Item = Result<DFChunk, GraphError>> + Send + 'a>, GraphError> {
     if paths.is_empty() {
         return Err(GraphError::LoadFailure(
             "No CSV files found at the provided path".to_string(),
         ));
     }
     // BoxedLIter couldn't be used because it has Send + Sync bound
-    type ChunkIter<'b> = Box<dyn Iterator<Item = Result<DFChunk, GraphError>> + 'b>;
+    // type ChunkIter<'b> = Box<dyn Iterator<Item = Result<DFChunk, GraphError>> + 'b>;
 
     let names = col_names.iter().map(|&name| name.to_string()).collect();
     let chunks = paths.iter().flat_map(move |path| {
         let schema = schema.clone();
         let csv_reader = match build_csv_reader(path.as_path(), csv_options) {
             Ok(r) => r,
-            Err(e) => return Box::new(iter::once(Err(e))) as ChunkIter<'a>,
+            Err(e) => return Iter3::I(iter::once(Err(e))),
         };
         let mut indices = Vec::with_capacity(col_names.len());
-        for required_col in &col_names {
+        for required_col in col_names {
             if let Some((idx, _)) = csv_reader
                 .schema()
                 .fields()
@@ -761,12 +799,12 @@ fn process_csv_paths_df<'a>(
             {
                 indices.push(idx);
             } else {
-                return Box::new(iter::once(Err(GraphError::ColumnDoesNotExist(
+                return Iter3::J(iter::once(Err(GraphError::ColumnDoesNotExist(
                     required_col.to_string(),
-                )))) as ChunkIter<'a>;
+                ))));
             }
         }
-        Box::new(
+        Iter3::K(
             csv_reader
                 .into_iter()
                 .map(move |batch_res| match batch_res {
@@ -787,7 +825,7 @@ fn process_csv_paths_df<'a>(
                         path.display()
                     ))),
                 }),
-        ) as ChunkIter<'a>
+        )
     });
 
     // we don't know the total number of rows until we read all files
diff --git a/raphtory/src/python/graph/mod.rs b/raphtory/src/python/graph/mod.rs
index 7dd45d7a3b..9450bd066d 100644
--- a/raphtory/src/python/graph/mod.rs
+++ b/raphtory/src/python/graph/mod.rs
@@ -1,5 +1,3 @@
-#[cfg(feature = "storage")]
-pub mod disk_graph;
 pub mod edge;
 pub mod graph;
 pub mod graph_with_deletions;
diff --git a/raphtory/src/python/graph/node.rs b/raphtory/src/python/graph/node.rs
index fc5d72f84b..9dc978bde1 100644
--- a/raphtory/src/python/graph/node.rs
+++ b/raphtory/src/python/graph/node.rs
@@ -51,7 +51,7 @@ use pyo3::{
     pybacked::PyBackedStr,
     pyclass, pymethods,
     types::PyDict,
-    IntoPyObjectExt, PyObject, PyResult, Python,
+    Borrowed, IntoPyObjectExt, Py, PyAny, PyResult, Python,
 };
 use python::{
     types::repr::{iterator_repr, Repr},
@@ -117,7 +117,7 @@ impl PyNode {
     ///    other: The other node to compare to.
     ///
     /// Returns:
-    ///   True if the nodes are equal, false otherwise.
+    ///   True if the nodes are equal, false otherwise.:
     fn __eq__(&self, other: Bound<PyNode>) -> bool {
         self.node.id() == other.get().node.id()
     }
@@ -145,7 +145,7 @@ impl PyNode {
     /// Returns the hash of the node.
     ///
     /// Returns:
-    ///   The node id.
+    ///   The node id.:
     pub fn __hash__(&self) -> u64 {
         calculate_hash(&self.node.id())
     }
@@ -379,24 +379,29 @@ impl PyMutableNode {
     ///                                      is of type Prop representing the property value.
     ///                                      If None, no properties are updated.
     ///    event_id (int, optional): The optional integer which will be used as an event id.
+    ///    layer (str, optional): The layer this update is recorded under. Defaults to None.
     ///
     /// Returns:
     ///     None: This function does not return a value, if the operation is successful.
     ///
     /// Raises:
     ///     GraphError: If the operation fails.
-    #[pyo3(signature = (t, properties=None, event_id=None))]
+    #[pyo3(signature = (t, properties=None, event_id=None, layer=None))]
     pub fn add_updates(
         &self,
         t: EventTimeComponent,
         properties: Option<HashMap<String, Prop>>,
         event_id: Option<usize>,
+        layer: Option<&str>,
     ) -> Result<(), GraphError> {
         match event_id {
-            None => self.node.add_updates(t, properties.unwrap_or_default()),
-            Some(event_id) => self
+            None => self
                 .node
-                .add_updates((t, event_id), properties.unwrap_or_default()),
+                .add_updates(t, properties.unwrap_or_default(), layer),
+            Some(event_id) => {
+                self.node
+                    .add_updates((t, event_id), properties.unwrap_or_default(), layer)
+            }
         }
     }
 
@@ -444,15 +449,18 @@ pub struct PyNodes {
     pub(crate) nodes: Nodes<'static, DynamicGraph, DynamicGraph, DynNodeFilter>,
 }
 
-impl<'py> FromPyObject<'py> for Nodes<'static, DynamicGraph, DynamicGraph, DynNodeFilter> {
-    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
-        Ok(ob.downcast::<PyNodes>()?.get().nodes.clone())
+impl<'py> FromPyObject<'_, 'py> for Nodes<'static, DynamicGraph, DynamicGraph, DynNodeFilter> {
+    type Error = PyErr;
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
+        Ok(ob.cast::<PyNodes>()?.get().nodes.clone())
     }
 }
 
-impl<'py> FromPyObject<'py> for Nodes<'static, DynamicGraph> {
-    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
-        let nodes = &ob.downcast::<PyNodes>()?.get().nodes;
+impl<'py> FromPyObject<'_, 'py> for Nodes<'static, DynamicGraph> {
+    type Error = PyErr;
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
+        let bound = ob.cast::<PyNodes>()?;
+        let nodes = &bound.get().nodes;
         if nodes.predicate.is_filtered() {
             Err(PyTypeError::new_err("Expected unfiltered nodes"))
         } else {
@@ -737,7 +745,7 @@ impl PyNodes {
         &self,
         include_property_history: bool,
         convert_datetime: bool,
-    ) -> PyResult<PyObject> {
+    ) -> PyResult<Py<PyAny>> {
         let mut column_names = vec![String::from("name"), String::from("type")];
         let meta = self.nodes.graph().node_meta();
         let is_prop_both_temp_and_const = get_column_names_from_props(&mut column_names, meta);
@@ -783,7 +791,7 @@ impl PyNodes {
             })
             .collect();
 
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let kwargs = PyDict::new(py);
             kwargs.set_item("columns", column_names.clone())?;
             let pandas = PyModule::import(py, "pandas")?;
@@ -845,7 +853,7 @@ impl PyPathFromGraph {
     #[getter]
     fn id(&self) -> NestedGIDIterable {
         let path = self.path.clone();
-        (move || path.id()).into()
+        (move || path.id().map(|(_, v)| v)).into()
     }
 
     /// The node names.
@@ -855,7 +863,7 @@ impl PyPathFromGraph {
     #[getter]
     fn name(&self) -> NestedStringIterable {
         let path = self.path.clone();
-        (move || path.name()).into()
+        (move || path.name().map(|(_, v)| v)).into()
     }
 
     /// The node types.
@@ -865,7 +873,7 @@ impl PyPathFromGraph {
     #[getter]
     fn node_type(&self) -> NestedOptionArcStringIterable {
         let path = self.path.clone();
-        (move || path.node_type()).into()
+        (move || path.node_type().map(|(_, v)| v)).into()
     }
 
     /// The node earliest times.
@@ -875,7 +883,7 @@ impl PyPathFromGraph {
     #[getter]
     fn earliest_time(&self) -> NestedOptionEventTimeIterable {
         let path = self.path.clone();
-        (move || path.earliest_time()).into()
+        (move || path.earliest_time().map(|(_, v)| v)).into()
     }
 
     /// The node latest times.
@@ -885,7 +893,7 @@ impl PyPathFromGraph {
     #[getter]
     fn latest_time(&self) -> NestedOptionEventTimeIterable {
         let path = self.path.clone();
-        (move || path.latest_time()).into()
+        (move || path.latest_time().map(|(_, v)| v)).into()
     }
 
     /// Returns a history object for each node with time entries for when a node is added or change to a node is made.
@@ -897,7 +905,7 @@ impl PyPathFromGraph {
         let path = self.path.clone();
         (move || {
             path.history()
-                .map(|h_iter| h_iter.map(|h| h.into_arc_dyn()))
+                .map(|(_, h_iter)| h_iter.map(|h| h.into_arc_dyn()))
         })
         .into()
     }
@@ -917,7 +925,7 @@ impl PyPathFromGraph {
     ///     NestedUsizeIterable:
     fn edge_history_count(&self) -> NestedUsizeIterable {
         let path = self.path.clone();
-        (move || path.edge_history_count()).into()
+        (move || path.edge_history_count().map(|(_, v)| v)).into()
     }
 
     /// Returns the node properties.
@@ -927,7 +935,7 @@ impl PyPathFromGraph {
     #[getter]
     fn properties(&self) -> PyNestedPropsIterable {
         let path = self.path.clone();
-        (move || path.properties()).into()
+        (move || path.properties().map(|(_, v)| v)).into()
     }
 
     /// Returns the node metadata.
@@ -937,7 +945,7 @@ impl PyPathFromGraph {
     #[getter]
     fn metadata(&self) -> MetadataListList {
         let path = self.path.clone();
-        (move || path.metadata()).into()
+        (move || path.metadata().map(|(_, v)| v)).into()
     }
 
     /// Returns the node degrees.
@@ -946,7 +954,7 @@ impl PyPathFromGraph {
     ///     NestedUsizeIterable:
     fn degree(&self) -> NestedUsizeIterable {
         let path = self.path.clone();
-        (move || path.degree()).into()
+        (move || path.degree().map(|(_, v)| v)).into()
     }
 
     /// Returns the node in-degrees.
@@ -955,7 +963,7 @@ impl PyPathFromGraph {
     ///     NestedUsizeIterable:
     fn in_degree(&self) -> NestedUsizeIterable {
         let path = self.path.clone();
-        (move || path.in_degree()).into()
+        (move || path.in_degree().map(|(_, v)| v)).into()
     }
 
     /// Returns the node out-degrees.
@@ -964,7 +972,7 @@ impl PyPathFromGraph {
     ///     NestedUsizeIterable:
     fn out_degree(&self) -> NestedUsizeIterable {
         let path = self.path.clone();
-        (move || path.out_degree()).into()
+        (move || path.out_degree().map(|(_, v)| v)).into()
     }
 
     /// filter nodes by type
diff --git a/raphtory/src/python/graph/node_state/mod.rs b/raphtory/src/python/graph/node_state/mod.rs
index f66f8551b6..3c4710b478 100644
--- a/raphtory/src/python/graph/node_state/mod.rs
+++ b/raphtory/src/python/graph/node_state/mod.rs
@@ -85,6 +85,7 @@ pub fn base_node_state_module(py: Python<'_>) -> PyResult<Bound<'_, PyModule>> {
         NodeStateSEIR,
         NodeLayout,
         NodeStateF64String,
+        PyOutputNodeState,
     );
     Ok(m)
 }
diff --git a/raphtory/src/python/graph/node_state/node_state.rs b/raphtory/src/python/graph/node_state/node_state.rs
index 0de352912e..2c126f17ef 100644
--- a/raphtory/src/python/graph/node_state/node_state.rs
+++ b/raphtory/src/python/graph/node_state/node_state.rs
@@ -62,7 +62,7 @@ macro_rules! impl_node_state_ops {
                 other: &Bound<'py, PyAny>,
                 py: Python<'py>,
             ) -> Result<Bound<'py, PyAny>, std::convert::Infallible> {
-                let res = if let Ok(other) = other.downcast::<Self>() {
+                let res = if let Ok(other) = other.cast::<Self>() {
                     let other = Bound::get(other);
                     self.inner == other.inner
                 } else if let Ok(other) = other.extract::<Vec<$value>>() {
@@ -72,7 +72,7 @@ macro_rules! impl_node_state_ops {
                         && other.into_iter().all(|(node, value)| {
                             self.inner.get_by_node(node).map($to_owned) == Some(value)
                         }))
-                } else if let Ok(other) = other.downcast::<PyDict>() {
+                } else if let Ok(other) = other.cast::<PyDict>() {
                     self.inner.len() == other.len()
                         && other.items().iter().all(|item| {
                             if let Ok((node_ref, value)) = item.extract::<(PyNodeRef, Bound<'py, PyAny>)>()
@@ -398,11 +398,12 @@ macro_rules! impl_lazy_node_state {
             }
         }
 
-        impl<'py> FromPyObject<'py>
+        impl<'py> FromPyObject<'_, 'py>
             for LazyNodeState<'static, $op, DynamicGraph, DynamicGraph, DynNodeFilter>
         {
-            fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
-                Ok(ob.downcast::<$name>()?.get().inner().clone())
+            type Error = PyErr;
+            fn extract(ob: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
+                Ok(ob.cast::<$name>()?.get().inner().clone())
             }
         }
     };
@@ -447,9 +448,10 @@ macro_rules! impl_node_state {
             }
         }
 
-        impl<'py> FromPyObject<'py> for NodeState<'static, $value, DynamicGraph> {
-            fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
-                Ok(ob.downcast::<$name>()?.get().inner().clone())
+        impl<'py> FromPyObject<'_, 'py> for NodeState<'static, $value, DynamicGraph> {
+            type Error = PyErr;
+            fn extract(ob: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
+                Ok(ob.cast::<$name>()?.get().inner().clone())
             }
         }
     };
@@ -608,3 +610,14 @@ impl_node_state!(
     "NodeStateF64String",
     "Tuple[float, str]"
 );
+
+impl_node_state!(
+    NodeStateF64StringI64<(f64, String, i64)>,
+    "NodeStateF64StringI64",
+    "Tuple[float, str, int]"
+);
+impl_node_state!(
+    NodeStateF64F64StringI64<(f64, f64, String, i64)>,
+    "NodeStateF64StringI64",
+    "Tuple[float, str, int]"
+);
diff --git a/raphtory/src/python/graph/node_state/node_state_earliest_time.rs b/raphtory/src/python/graph/node_state/node_state_earliest_time.rs
index 43becc8474..c323f05ae4 100644
--- a/raphtory/src/python/graph/node_state/node_state_earliest_time.rs
+++ b/raphtory/src/python/graph/node_state/node_state_earliest_time.rs
@@ -186,7 +186,7 @@ impl EarliestDateTimeView {
         other: &Bound<'py, PyAny>,
         py: Python<'py>,
     ) -> Result<Bound<'py, PyAny>, std::convert::Infallible> {
-        let res = if let Ok(other) = other.downcast::<Self>() {
+        let res = if let Ok(other) = other.cast::<Self>() {
             let other = Bound::get(other);
             self.inner == other.inner
         } else if let Ok(other) = other.extract::<Vec<Option<DateTime<Utc>>>>() {
@@ -198,7 +198,7 @@ impl EarliestDateTimeView {
                 && other
                     .into_iter()
                     .all(|(node, value)| self.inner.get_by_node(node) == Some(Ok(value)))
-        } else if let Ok(other) = other.downcast::<PyDict>() {
+        } else if let Ok(other) = other.cast::<PyDict>() {
             self.inner.len() == other.len()
                 && other.items().iter().all(|item| {
                     if let Ok((node_ref, value)) = item.extract::<(PyNodeRef, Bound<'py, PyAny>)>()
@@ -252,10 +252,10 @@ impl EarliestDateTimeView {
     ///
     /// Arguments:
     ///     node (NodeInput): the node
-    #[doc = "    default (Optional[datetime]): the default value. Defaults to None."]
+    ///     default (Optional[datetime]): the default value. Defaults to None.
     ///
     /// Returns:
-    #[doc = "    Optional[datetime]: the value for the node or the default value"]
+    ///     Optional[datetime]: the value for the node or the default value
     #[pyo3(signature = (node, default=None::<DateTime<Utc>>))]
     fn get(
         &self,
@@ -584,10 +584,11 @@ impl<'py> pyo3::IntoPyObject<'py>
     }
 }
 
-impl<'py> FromPyObject<'py>
+impl<'py> FromPyObject<'_, 'py>
     for LazyNodeState<'static, EarliestDateTime, DynamicGraph, DynamicGraph, DynNodeFilter>
 {
-    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
-        Ok(ob.downcast::<EarliestDateTimeView>()?.get().inner().clone())
+    type Error = PyErr;
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
+        Ok(ob.cast::<EarliestDateTimeView>()?.get().inner().clone())
     }
 }
diff --git a/raphtory/src/python/graph/node_state/node_state_history.rs b/raphtory/src/python/graph/node_state/node_state_history.rs
index 93e66f7562..568156916f 100644
--- a/raphtory/src/python/graph/node_state/node_state_history.rs
+++ b/raphtory/src/python/graph/node_state/node_state_history.rs
@@ -232,7 +232,7 @@ impl HistoryView {
         other: &Bound<'py, PyAny>,
         py: Python<'py>,
     ) -> Result<Bound<'py, PyAny>, std::convert::Infallible> {
-        let res = if let Ok(other) = other.downcast::<Self>() {
+        let res = if let Ok(other) = other.cast::<Self>() {
             let other = Bound::get(other);
             self.inner == other.inner
         } else if let Ok(other) =
@@ -254,7 +254,7 @@ impl HistoryView {
                         .map(|v| v.iter().eq(value.iter()))
                         .unwrap_or(false)
                 })
-        } else if let Ok(other) = other.downcast::<PyDict>() {
+        } else if let Ok(other) = other.cast::<PyDict>() {
             NodeStateOps::len(&self.inner) == other.len()
                 && other.items().iter().all(|item| {
                     if let Ok((node_ref, value)) = item.extract::<(PyNodeRef, Bound<'py, PyAny>)>()
@@ -423,7 +423,7 @@ impl<'py> pyo3::IntoPyObject<'py>
     }
 }
 
-impl<'py> FromPyObject<'py>
+impl<'py> FromPyObject<'_, 'py>
     for LazyNodeState<
         'static,
         HistoryOp<'static, DynamicGraph>,
@@ -432,14 +432,12 @@ impl<'py> FromPyObject<'py>
         DynNodeFilter,
     >
 {
-    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
-        Ok(ob.downcast::<HistoryView>()?.get().inner().clone())
+    type Error = PyErr;
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
+        Ok(ob.cast::<HistoryView>()?.get().inner().clone())
     }
 }
 
-#[allow(dead_code)]
-type HistoryOpType<G> = HistoryOp<'static, G>;
-
 /// A NodeState of History objects for each node.
 #[pyclass(module = "raphtory.node_state", frozen)]
 pub struct NodeStateHistory {
@@ -574,7 +572,7 @@ impl NodeStateHistory {
         other: &Bound<'py, PyAny>,
         py: Python<'py>,
     ) -> Result<Bound<'py, PyAny>, std::convert::Infallible> {
-        let res = if let Ok(other) = other.downcast::<Self>() {
+        let res = if let Ok(other) = other.cast::<Self>() {
             let other = Bound::get(other);
             self.inner == other.inner
         } else if let Ok(other) =
@@ -596,7 +594,7 @@ impl NodeStateHistory {
                         .map(|v| v.iter().eq(value.iter()))
                         .unwrap_or(false)
                 })
-        } else if let Ok(other) = other.downcast::<PyDict>() {
+        } else if let Ok(other) = other.cast::<PyDict>() {
             self.inner.len() == other.len()
                 && other.items().iter().all(|item| {
                     if let Ok((node_ref, value)) = item.extract::<(PyNodeRef, Bound<'py, PyAny>)>()
@@ -739,11 +737,12 @@ impl<'py> pyo3::IntoPyObject<'py>
     }
 }
 
-impl<'py> FromPyObject<'py>
+impl<'py> FromPyObject<'_, 'py>
     for NodeState<'static, History<'static, NodeView<'static, DynamicGraph>>, DynamicGraph>
 {
-    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
-        Ok(ob.downcast::<NodeStateHistory>()?.get().inner().clone())
+    type Error = PyErr;
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
+        Ok(ob.cast::<NodeStateHistory>()?.get().inner().clone())
     }
 }
 
diff --git a/raphtory/src/python/graph/node_state/node_state_latest_time.rs b/raphtory/src/python/graph/node_state/node_state_latest_time.rs
index e24ccef25b..76d39e47f0 100644
--- a/raphtory/src/python/graph/node_state/node_state_latest_time.rs
+++ b/raphtory/src/python/graph/node_state/node_state_latest_time.rs
@@ -209,7 +209,7 @@ impl LatestDateTimeView {
         other: &Bound<'py, PyAny>,
         py: Python<'py>,
     ) -> Result<Bound<'py, PyAny>, std::convert::Infallible> {
-        let res = if let Ok(other) = other.downcast::<Self>() {
+        let res = if let Ok(other) = other.cast::<Self>() {
             let other = Bound::get(other);
             self.inner == other.inner
         } else if let Ok(other) = other.extract::<Vec<Option<DateTime<Utc>>>>() {
@@ -221,7 +221,7 @@ impl LatestDateTimeView {
                 && other
                     .into_iter()
                     .all(|(node, value)| self.inner.get_by_node(node) == Some(Ok(value)))
-        } else if let Ok(other) = other.downcast::<PyDict>() {
+        } else if let Ok(other) = other.cast::<PyDict>() {
             self.inner.len() == other.len()
                 && other.items().iter().all(|item| {
                     if let Ok((node_ref, value)) = item.extract::<(PyNodeRef, Bound<'py, PyAny>)>()
@@ -651,7 +651,7 @@ impl<'py> pyo3::IntoPyObject<'py>
     }
 }
 
-impl<'py> FromPyObject<'py>
+impl<'py> FromPyObject<'_, 'py>
     for LazyNodeState<
         'static,
         LatestDateTime<DynamicGraph>,
@@ -660,7 +660,8 @@ impl<'py> FromPyObject<'py>
         DynNodeFilter,
     >
 {
-    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
-        Ok(ob.downcast::<LatestDateTimeView>()?.get().inner().clone())
+    type Error = PyErr;
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
+        Ok(ob.cast::<LatestDateTimeView>()?.get().inner().clone())
     }
 }
diff --git a/raphtory/src/python/graph/node_state/output_node_state.rs b/raphtory/src/python/graph/node_state/output_node_state.rs
index 6644190386..287521321f 100644
--- a/raphtory/src/python/graph/node_state/output_node_state.rs
+++ b/raphtory/src/python/graph/node_state/output_node_state.rs
@@ -1,5 +1,3 @@
-use std::collections::HashMap;
-
 use crate::{
     core::entities::nodes::node_ref::{AsNodeRef, NodeRef},
     db::{
@@ -8,7 +6,10 @@ use crate::{
                 convert_prop_map, ops::Const, GenericNodeState, MergePriority, NodeStateOutput,
                 OutputTypedNodeState, TransformedPropMap, TypedNodeState,
             },
-            view::DynamicGraph,
+            view::{
+                internal::IntoDynamicOrMutable, BoxableGraphView, DynamicGraph, IntoDynamic,
+                StaticGraphViewOps,
+            },
         },
         graph::nodes::Nodes,
     },
@@ -16,7 +17,7 @@ use crate::{
     python::{
         graph::{
             node::{PyNode, PyNodes},
-            node_state::NodeFilterOp,
+            node_state::{NodeFilterOp, NodeView},
         },
         types::{repr::Repr, wrappers::iterators::PyBorrowingIterator},
         utils::PyNodeRef,
@@ -27,15 +28,12 @@ use pyo3::{
     exceptions::{PyKeyError, PyTypeError},
     pyclass, pymethods,
     types::{PyAnyMethods, PyDict, PyDictMethods, PyNotImplemented},
-    Bound, FromPyObject, IntoPyObject, IntoPyObjectExt, PyAny, PyErr, PyObject, PyResult, Python,
+    Borrowed, Bound, FromPyObject, IntoPyObject, IntoPyObjectExt, PyAny, PyErr, PyResult, Python,
 };
 use raphtory_api::core::entities::properties::prop::PropUntagged;
+use std::{collections::HashMap, sync::Arc};
 
-#[pyclass(
-    name = "OutputNodeState",
-    module = "raphtory.output_node_state",
-    frozen
-)]
+#[pyclass(name = "OutputNodeState", module = "raphtory.node_state", frozen)]
 pub struct PyOutputNodeState {
     pub inner: OutputTypedNodeState<'static, DynamicGraph>,
 }
@@ -68,7 +66,7 @@ impl PyOutputNodeState {
         other: &Bound<'py, PyAny>,
         py: Python<'py>,
     ) -> Result<Bound<'py, PyAny>, std::convert::Infallible> {
-        let res = if let Ok(other) = other.downcast::<Self>() {
+        let res = if let Ok(other) = other.cast::<Self>() {
             let other = Bound::get(other);
             self.inner == other.inner
         } else if let Ok(other) = other.extract::<Vec<IndexMap<String, Option<Prop>>>>() {
@@ -76,8 +74,8 @@ impl PyOutputNodeState {
         } else if let Ok(other) =
             other.extract::<HashMap<PyNodeRef, HashMap<String, Option<Prop>>>>()
         {
-            self.inner.try_eq_hashmap(other).unwrap()
-        } else if let Ok(other) = other.downcast::<PyDict>() {
+            self.inner.try_eq_hashmap(other).unwrap_or(false)
+        } else if let Ok(other) = other.cast::<PyDict>() {
             self.inner.len() == other.len()
                 && other.items().try_iter().unwrap().all(|item| {
                     if let Ok((node_ref, value)) =
@@ -108,7 +106,10 @@ impl PyOutputNodeState {
         self.inner.repr()
     }
 
-    fn __getitem__(&self, node: PyNodeRef) -> PyResult<TransformedPropMap<'static, DynamicGraph>> {
+    fn __getitem__(
+        &self,
+        node: PyNodeRef,
+    ) -> PyResult<TransformedPropMap<'static, Arc<dyn BoxableGraphView>>> {
         let node = node.as_node_ref();
         self.inner
             .get_by_node(node)
@@ -131,16 +132,16 @@ impl PyOutputNodeState {
     ///
     /// Arguments:
     ///     node (NodeInput): the node
-    ///     default (Optional[Dict]): the default value (dict of field name to value). Defaults to None.")]
+    ///     default (dict, optional): the default value (dict of field name to value). Defaults to None.
     ///
     /// Returns:
-    ///     Optional[Dict]: the value for the node or the default value")]
-    #[pyo3(signature = (node, default=None::<TransformedPropMap<'static, DynamicGraph>>))]
+    ///     Optional[dict]: the value for the node or the default value
+    #[pyo3(signature = (node, default=None::<TransformedPropMap<'static, Arc<dyn BoxableGraphView>>>))]
     fn get(
         &self,
         node: PyNodeRef,
-        default: Option<TransformedPropMap<'static, DynamicGraph>>,
-    ) -> Option<TransformedPropMap<'static, DynamicGraph>> {
+        default: Option<TransformedPropMap<'static, Arc<dyn BoxableGraphView>>>,
+    ) -> Option<TransformedPropMap<'static, Arc<dyn BoxableGraphView>>> {
         self.inner
             .get_by_node(node)
             .map_or(default, |value| Some(self.inner.convert(value)))
@@ -196,6 +197,7 @@ impl PyOutputNodeState {
     ///
     /// Arguments:
     ///     sort_params (Dict): Map of sort keys to sort option ('asc' or 'desc'). None defaults to 'asc'
+    ///     k (int): Number of top entries to return.
     ///
     /// Returns:
     ///     OutputNodeState: Sorted NodeState
@@ -214,15 +216,15 @@ impl PyOutputNodeState {
     /// Group by value
     ///
     /// Arguments:
-    ///     cols (List[Str]): columns by which to group nodes
+    ///     cols (list[str]): columns by which to group nodes
     ///
     /// Returns:
-    ///     List[Tuple[Dict, Nodes]]: The grouped nodes
+    ///     list[tuple[dict, Nodes]]: The grouped nodes
     fn groups(
         &self,
         cols: Vec<String>,
     ) -> Vec<(
-        TransformedPropMap<'static, DynamicGraph>,
+        TransformedPropMap<'static, Arc<dyn BoxableGraphView>>,
         Nodes<'static, DynamicGraph>,
     )> {
         self.inner.get_groups(cols).unwrap()
@@ -232,24 +234,27 @@ impl PyOutputNodeState {
     //    self.inner.sort_by_id()
     //}
 
-    /// Convert TypedNodeState to Parquet
+    /// Convert OutputNodeState to Parquet
     ///
     /// Arguments:
-    ///     file_path (Str): filepath to which TypedNodeState is written
-    ///     id_column (Str): column containing IDs of nodes
+    ///     file_path (str): filepath to which OutputNodeState is written
+    ///     id_column (str): column containing IDs of nodes. Defaults to "id".
+    ///
+    /// Returns:
+    ///     None:
     #[pyo3(signature = (file_path, id_column="id".to_string()))]
     fn to_parquet(&self, file_path: String, id_column: String) {
         self.inner.state.to_parquet(file_path, Some(id_column));
     }
 
-    /// Get TypedNodeState from Parquet
+    /// Get OutputNodeState from Parquet
     ///
     /// Arguments:
-    ///     file_path (Str): filepath from which to read TypedNodeState
-    ///     id_column (Str): column to which node IDs will be written
+    ///     file_path (str): filepath from which to read OutputNodeState
+    ///     id_column (str): column to which node IDs will be written. Defaults to "id".
     ///
     /// Returns:
-    ///     TypedNodeState
+    ///     OutputNodeState:
     #[pyo3(signature = (file_path, id_column="id".to_string()))]
     fn from_parquet(&self, file_path: String, id_column: String) -> PyResult<Self> {
         Ok(PyOutputNodeState {
@@ -260,16 +265,16 @@ impl PyOutputNodeState {
         })
     }
 
-    /// Merge with another TypedNodeState (produces new TypedNodeState)
+    /// Merge with another OutputNodeState (produces new OutputNodeState)
     ///
     /// Arguments:
-    ///     other (TypedNodeState): TypedNodeState to merge with
-    ///     index_merge_priority (Str): "left" or "right" to take left or right index, "union" to union index sets
-    ///     default_column_merge_priority (Str): "left" or "right" to prioritize left or right columns by default, "exclude" to exclude columns by default
-    ///     column_merge_priority_map (Dict): map of column names (Str) to merge priority ("left", "right", or "exclude")
+    ///     other (OutputNodeState): OutputNodeState to merge with
+    ///     index_merge_priority (str): "left" or "right" to take left or right index, "union" to union index sets. Defaults to "left".
+    ///     default_column_merge_priority (str): "left" or "right" to prioritize left or right columns by default, "exclude" to exclude columns by default. Defaults to "left".
+    ///     column_merge_priority_map (dict, optional): map of column names (str) to merge priority ("left", "right", or "exclude"). Defaults to None.
     ///
     /// Returns:
-    ///     TypedNodeState
+    ///     OutputNodeState:
     #[pyo3(signature = (other, index_merge_priority="left".to_string(), default_column_merge_priority="left".to_string(), column_merge_priority_map=None::<HashMap<String, String>>))]
     fn merge<'py>(
         &self,
@@ -314,7 +319,7 @@ impl PyOutputNodeState {
             )
         }
 
-        let res = if let Ok(other) = other.downcast::<Self>() {
+        let res = if let Ok(other) = other.cast::<Self>() {
             let other = Bound::get(other);
             self.inner.state.merge(
                 &other.inner.state,
@@ -341,7 +346,9 @@ impl<'py> IntoPyObject<'py> for OutputTypedNodeState<'static, DynamicGraph> {
     }
 }
 
-impl<'py> IntoPyObject<'py> for NodeStateOutput<'static, DynamicGraph> {
+impl<'py, G: StaticGraphViewOps + IntoDynamicOrMutable> IntoPyObject<'py>
+    for NodeStateOutput<'static, G>
+{
     type Target = PyAny;
     type Output = Bound<'py, PyAny>;
     type Error = PyErr;
@@ -355,9 +362,11 @@ impl<'py> IntoPyObject<'py> for NodeStateOutput<'static, DynamicGraph> {
     }
 }
 
-impl<'py> FromPyObject<'py> for NodeStateOutput<'static, DynamicGraph> {
-    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
-        if let Ok(nodes) = ob.downcast::<PyNodes>() {
+impl<'a, 'py> FromPyObject<'a, 'py> for NodeStateOutput<'static, DynamicGraph> {
+    type Error = PyErr;
+
+    fn extract(obj: Borrowed<'a, 'py, PyAny>) -> Result<Self, Self::Error> {
+        if let Ok(nodes) = obj.cast::<PyNodes>() {
             if nodes.get().nodes.predicate.is_filtered() {
                 return Err(PyTypeError::new_err(
                     "Trying to read filtered Nodes object.",
@@ -368,14 +377,34 @@ impl<'py> FromPyObject<'py> for NodeStateOutput<'static, DynamicGraph> {
             return Ok(NodeStateOutput::Nodes(nodes));
         }
 
-        if let Ok(node) = ob.downcast::<PyNode>() {
+        if let Ok(node) = obj.cast::<PyNode>() {
             return Ok(NodeStateOutput::Node(node.get().node.clone()));
         }
 
-        if let Ok(prop) = ob.extract::<Option<Prop>>() {
+        if let Ok(prop) = obj.extract::<Option<Prop>>() {
             return Ok(NodeStateOutput::Prop(prop.map(PropUntagged::from)));
         }
 
-        return Err(PyTypeError::new_err("Invalid type conversion"));
+        Err(PyTypeError::new_err("Invalid type conversion"))
+    }
+}
+
+impl<'a, 'py> FromPyObject<'a, 'py> for NodeStateOutput<'static, Arc<dyn BoxableGraphView>> {
+    type Error = PyErr;
+
+    fn extract(obj: Borrowed<'a, 'py, PyAny>) -> Result<Self, Self::Error> {
+        let obj = NodeStateOutput::<'static, DynamicGraph>::extract(obj)?;
+        Ok(match obj {
+            NodeStateOutput::Node(node) => {
+                NodeStateOutput::Node(NodeView::new_internal(node.graph.0, node.node))
+            }
+            NodeStateOutput::Nodes(nodes) => NodeStateOutput::Nodes(Nodes::new_filtered(
+                nodes.base_graph.0,
+                nodes.graph.0,
+                nodes.predicate,
+                nodes.nodes,
+            )),
+            NodeStateOutput::Prop(prop) => NodeStateOutput::Prop(prop),
+        })
     }
 }
diff --git a/raphtory/src/python/graph/properties/metadata.rs b/raphtory/src/python/graph/properties/metadata.rs
index 4b1fc4bc70..77e9a0d29c 100644
--- a/raphtory/src/python/graph/properties/metadata.rs
+++ b/raphtory/src/python/graph/properties/metadata.rs
@@ -156,6 +156,10 @@ py_eq!(MetadataView, PyPropsListCmp);
 
 #[pymethods]
 impl MetadataView {
+    /// Metadata keys present across the underlying entities.
+    ///
+    /// Returns:
+    ///     list[str]:
     pub fn keys(&self) -> Vec<ArcStr> {
         self.iter()
             .next()
@@ -163,12 +167,21 @@ impl MetadataView {
             .unwrap_or_default()
     }
 
+    /// Metadata values aligned with `keys()`.
+    ///
+    /// Returns:
+    ///     list[PyPropValueList]:
     pub fn values(&self) -> Vec<PyPropValueList> {
         self.keys()
             .into_iter()
             .map(|k| self.get(k).expect("key exists"))
             .collect()
     }
+
+    /// Pairs of `(key, value list)` for every metadata key.
+    ///
+    /// Returns:
+    ///     list[tuple[str, PyPropValueList]]:
     pub fn items(&self) -> Vec<(ArcStr, PyPropValueList)> {
         self.keys().into_iter().zip(self.values()).collect()
     }
@@ -177,6 +190,13 @@ impl MetadataView {
         self.get(key).ok_or(PyKeyError::new_err("No such property"))
     }
 
+    /// Look up a metadata value by key.
+    ///
+    /// Arguments:
+    ///     key (str): metadata key.
+    ///
+    /// Returns:
+    ///     Optional[PyPropValueList]:
     pub fn get(&self, key: ArcStr) -> Option<PyPropValueList> {
         self.__contains__(&key).then(|| {
             let builder = self.builder.clone();
@@ -197,6 +217,11 @@ impl MetadataView {
         self.keys().into_iter().into()
     }
 
+    /// Materialise the metadata as a plain dict mapping each key to the
+    /// list of values seen across the underlying entities.
+    ///
+    /// Returns:
+    ///     dict[str, list]:
     pub fn as_dict(&self) -> HashMap<ArcStr, Vec<Option<Prop>>> {
         self.items()
             .into_iter()
@@ -210,6 +235,10 @@ py_eq!(MetadataListList, PyMetadataListListCmp);
 
 #[pymethods]
 impl MetadataListList {
+    /// Metadata keys present across the underlying entities.
+    ///
+    /// Returns:
+    ///     list[str]:
     pub fn keys(&self) -> Vec<ArcStr> {
         self.iter()
             .flat_map(|mut it| it.next().map(|p| p.keys().collect()))
@@ -217,12 +246,21 @@ impl MetadataListList {
             .unwrap_or_default()
     }
 
+    /// Per-key list of value lists.
+    ///
+    /// Returns:
+    ///     list[PyPropValueListList]:
     pub fn values(&self) -> Vec<PyPropValueListList> {
         self.keys()
             .into_iter()
             .map(|k| self.get(k).expect("key exists"))
             .collect()
     }
+
+    /// Pairs of `(key, value list-of-lists)` for every metadata key.
+    ///
+    /// Returns:
+    ///     list[tuple[str, PyPropValueListList]]:
     pub fn items(&self) -> Vec<(ArcStr, PyPropValueListList)> {
         self.keys().into_iter().zip(self.values()).collect()
     }
@@ -235,6 +273,13 @@ impl MetadataListList {
         self.keys().into_iter().into()
     }
 
+    /// Look up the metadata for `key` across all entities.
+    ///
+    /// Arguments:
+    ///     key (str): metadata key.
+    ///
+    /// Returns:
+    ///     Optional[PyPropValueListList]:
     pub fn get(&self, key: ArcStr) -> Option<PyPropValueListList> {
         self.__contains__(&key).then(|| {
             let builder = self.builder.clone();
@@ -257,6 +302,10 @@ impl MetadataListList {
             .is_some_and(|p| p.contains(key))
     }
 
+    /// Materialise as a dict mapping each key to a list of value lists.
+    ///
+    /// Returns:
+    ///     dict[str, list]:
     pub fn as_dict(&self) -> HashMap<ArcStr, Vec<Vec<Option<Prop>>>> {
         self.items()
             .into_iter()
diff --git a/raphtory/src/python/graph/properties/props.rs b/raphtory/src/python/graph/properties/props.rs
index 17e0e47448..e5dc221e0f 100644
--- a/raphtory/src/python/graph/properties/props.rs
+++ b/raphtory/src/python/graph/properties/props.rs
@@ -39,8 +39,9 @@ impl PartialEq for PyPropsComp {
     }
 }
 
-impl<'source> FromPyObject<'source> for PyPropsComp {
-    fn extract_bound(ob: &Bound<'source, PyAny>) -> PyResult<Self> {
+impl<'py> FromPyObject<'_, 'py> for PyPropsComp {
+    type Error = PyErr;
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
         if let Ok(sp) = ob.extract::<PyRef<PyMetadata>>() {
             Ok(sp.deref().into())
         } else if let Ok(p) = ob.extract::<PyRef<PyProperties>>() {
@@ -250,8 +251,9 @@ impl Repr for PyProperties {
 #[derive(PartialEq, Clone)]
 pub struct PyPropsListCmp(HashMap<ArcStr, PyPropValueListCmp>);
 
-impl<'source> FromPyObject<'source> for PyPropsListCmp {
-    fn extract_bound(ob: &Bound<'source, PyAny>) -> PyResult<Self> {
+impl<'py> FromPyObject<'_, 'py> for PyPropsListCmp {
+    type Error = PyErr;
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
         if let Ok(sp) = ob.extract::<PyRef<MetadataView>>() {
             Ok(sp.deref().into())
         } else if let Ok(p) = ob.extract::<PyRef<PropertiesView>>() {
@@ -372,7 +374,7 @@ impl PropertiesView {
     /// Get a view of the temporal properties only.
     ///
     /// Returns:
-    ///     List[TemporalProp]:
+    ///     list[TemporalProperty]:
     #[getter]
     pub fn temporal(&self) -> PyTemporalPropsList {
         let builder = self.builder.clone();
@@ -404,8 +406,9 @@ py_eq!(PyNestedPropsIterable, PyMetadataListListCmp);
 #[derive(PartialEq, Clone)]
 pub struct PyMetadataListListCmp(HashMap<ArcStr, PyPropValueListListCmp>);
 
-impl<'source> FromPyObject<'source> for PyMetadataListListCmp {
-    fn extract_bound(ob: &Bound<'source, PyAny>) -> PyResult<Self> {
+impl<'py> FromPyObject<'_, 'py> for PyMetadataListListCmp {
+    type Error = PyErr;
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
         if let Ok(sp) = ob.extract::<PyRef<MetadataListList>>() {
             Ok(sp.deref().into())
         } else if let Ok(p) = ob.extract::<PyRef<PyNestedPropsIterable>>() {
@@ -450,7 +453,7 @@ impl PyNestedPropsIterable {
     ///     key (str): the name of the property.
     ///
     /// Returns:
-    ///     PyPropValueListList:
+    ///     Optional[PyPropValueListList]:
     pub fn get(&self, key: &str) -> Option<PyPropValueListList> {
         self.__contains__(key).then(|| {
             let builder = self.builder.clone();
@@ -481,7 +484,7 @@ impl PyNestedPropsIterable {
     /// Get the names for all properties.
     ///
     /// Returns:
-    ///     List[Str]:
+    ///     list[str]:
     pub fn keys(&self) -> Vec<ArcStr> {
         self.iter()
             .filter_map(|mut it| it.next())
@@ -517,7 +520,7 @@ impl PyNestedPropsIterable {
     /// Get a view of the temporal properties only.
     ///
     /// Returns:
-    ///     List[List[temporalprop]]:
+    ///     list[list[TemporalProperty]]:
     #[getter]
     pub fn temporal(&self) -> PyTemporalPropsListList {
         let builder = self.builder.clone();
diff --git a/raphtory/src/python/graph/properties/temporal_props.rs b/raphtory/src/python/graph/properties/temporal_props.rs
index b06e4aaba0..27c1a1d879 100644
--- a/raphtory/src/python/graph/properties/temporal_props.rs
+++ b/raphtory/src/python/graph/properties/temporal_props.rs
@@ -30,6 +30,7 @@ use itertools::Itertools;
 use pyo3::{
     exceptions::{PyKeyError, PyTypeError},
     prelude::*,
+    Borrowed,
 };
 use raphtory_api::core::{
     entities::properties::prop::{Prop, PropUnwrap},
@@ -69,8 +70,9 @@ impl From<&PyTemporalProperties> for PyTemporalPropsCmp {
     }
 }
 
-impl<'source> FromPyObject<'source> for PyTemporalPropsCmp {
-    fn extract_bound(ob: &Bound<'source, PyAny>) -> PyResult<Self> {
+impl<'py> FromPyObject<'_, 'py> for PyTemporalPropsCmp {
+    type Error = PyErr;
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
         if let Ok(v) = ob.extract::<PyRef<PyTemporalProperties>>() {
             Ok(PyTemporalPropsCmp::from(v.deref()))
         } else if let Ok(v) = ob.extract::<HashMap<ArcStr, PyTemporalPropCmp>>() {
@@ -186,8 +188,9 @@ pub struct PyTemporalProp {
 #[derive(Clone, PartialEq)]
 pub struct PyTemporalPropCmp(Vec<(i64, Prop)>);
 
-impl<'source> FromPyObject<'source> for PyTemporalPropCmp {
-    fn extract_bound(ob: &Bound<'source, PyAny>) -> PyResult<Self> {
+impl<'py> FromPyObject<'_, 'py> for PyTemporalPropCmp {
+    type Error = PyErr;
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
         if let Ok(sp) = ob.extract::<PyRef<PyTemporalProp>>() {
             Ok(sp.deref().into())
         } else if let Ok(m) = ob.extract::<Vec<(i64, Prop)>>() {
@@ -238,7 +241,7 @@ impl PyTemporalProp {
     /// Get the property values for each update.
     ///
     /// Returns:
-    ///     NumpyArray:
+    ///     NDArray: a numpy array of values, one per update.
     pub fn values(&self) -> NumpyArray {
         self.prop.values().collect()
     }
@@ -300,7 +303,7 @@ impl PyTemporalProp {
     /// Returns:
     ///     PropValue: The sum of all property values.
     pub fn sum(&self) -> Option<Prop> {
-        compute_generalised_sum(self.prop.values(), |a, b| a.add(b), |d| d.dtype().has_add())
+        self.prop.sum()
     }
 
     /// Find the minimum property value and its associated time.
@@ -308,17 +311,7 @@ impl PyTemporalProp {
     /// Returns:
     ///     Tuple[EventTime, PropValue]: A tuple containing the time and the minimum property value.
     pub fn min(&self) -> Option<(EventTime, Prop)> {
-        compute_generalised_sum(
-            self.prop.iter(),
-            |a, b| {
-                if a.1.partial_cmp(&b.1)?.is_le() {
-                    Some(a)
-                } else {
-                    Some(b)
-                }
-            },
-            |d| d.1.dtype().has_cmp(),
-        )
+        self.prop.min()
     }
 
     /// Find the maximum property value and its associated time.
@@ -326,17 +319,7 @@ impl PyTemporalProp {
     /// Returns:
     ///     Tuple[EventTime, PropValue]: A tuple containing the time and the maximum property value.
     pub fn max(&self) -> Option<(EventTime, Prop)> {
-        compute_generalised_sum(
-            self.prop.iter(),
-            |a, b| {
-                if a.1.partial_cmp(&b.1)?.is_ge() {
-                    Some(a)
-                } else {
-                    Some(b)
-                }
-            },
-            |d| d.1.dtype().has_cmp(),
-        )
+        self.prop.max()
     }
 
     /// Count the number of properties.
@@ -344,7 +327,7 @@ impl PyTemporalProp {
     /// Returns:
     ///     int: The number of properties.
     pub fn count(&self) -> usize {
-        self.prop.iter().count()
+        self.prop.count()
     }
 
     /// Compute the average of all property values. Alias for mean().
@@ -352,7 +335,7 @@ impl PyTemporalProp {
     /// Returns:
     ///     PropValue: The average of each property values, or None if count is zero.
     pub fn average(&self) -> Option<Prop> {
-        self.mean()
+        self.prop.average()
     }
 
     /// Compute the mean of all property values. Alias for mean().
@@ -360,7 +343,7 @@ impl PyTemporalProp {
     /// Returns:
     ///     PropValue: The mean of each property values, or None if count is zero.
     pub fn mean(&self) -> Option<Prop> {
-        compute_mean(self.prop.values())
+        self.prop.mean()
     }
 
     /// Compute the median of all property values.
@@ -368,17 +351,7 @@ impl PyTemporalProp {
     /// Returns:
     ///     Tuple[EventTime, PropValue]: A tuple containing the time and the median property value, or None if empty
     pub fn median(&self) -> Option<(EventTime, Prop)> {
-        let mut sorted: Vec<(EventTime, Prop)> = self.prop.iter().collect();
-        if !sorted.first()?.1.dtype().has_cmp() {
-            return None;
-        }
-        sorted.sort_by(|a, b| a.1.partial_cmp(&b.1).unwrap_or(std::cmp::Ordering::Equal));
-        let len = sorted.len();
-        if len == 0 {
-            None
-        } else {
-            Some(sorted[(len - 1) / 2].clone())
-        }
+        self.prop.median()
     }
 
     pub fn __repr__(&self) -> String {
@@ -497,8 +470,9 @@ impl From<HashMap<ArcStr, PyTemporalPropListCmp>> for PyTemporalPropsListCmp {
     }
 }
 
-impl<'source> FromPyObject<'source> for PyTemporalPropsListCmp {
-    fn extract_bound(ob: &Bound<'source, PyAny>) -> PyResult<Self> {
+impl<'py> FromPyObject<'_, 'py> for PyTemporalPropsListCmp {
+    type Error = PyErr;
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
         if let Ok(v) = ob.extract::<PyRef<PyTemporalPropsList>>() {
             Ok(PyTemporalPropsListCmp::from(v.deref()))
         } else if let Ok(v) = ob.extract::<HashMap<ArcStr, PyTemporalPropListCmp>>() {
@@ -513,22 +487,40 @@ py_eq!(PyTemporalPropsList, PyTemporalPropsListCmp);
 
 #[pymethods]
 impl PyTemporalPropsList {
+    /// Property keys present across the underlying entities.
+    ///
+    /// Returns:
+    ///     list[str]:
     fn keys(&self) -> Vec<ArcStr> {
         self.iter()
             .next()
             .map(|p| p.keys().collect())
             .unwrap_or_default()
     }
+
+    /// Per-key list of temporal property views.
+    ///
+    /// Returns:
+    ///     list[PyTemporalPropList]:
     fn values(&self) -> Vec<PyTemporalPropList> {
         self.keys()
             .into_iter()
             .map(|k| self.get(k).expect("key exists"))
             .collect()
     }
+
+    /// Pairs of `(key, temporal property list)` for every property key.
+    ///
+    /// Returns:
+    ///     list[tuple[str, PyTemporalPropList]]:
     fn items(&self) -> Vec<(ArcStr, PyTemporalPropList)> {
         self.keys().into_iter().zip(self.values()).collect()
     }
 
+    /// Latest value of each property across the underlying entities.
+    ///
+    /// Returns:
+    ///     dict[str, PyPropValueList]:
     fn latest(&self) -> HashMap<ArcStr, PyPropValueList> {
         let builder = self.builder.clone();
         self.keys()
@@ -548,6 +540,10 @@ impl PyTemporalPropsList {
             .collect()
     }
 
+    /// Full update history of each property across the underlying entities.
+    ///
+    /// Returns:
+    ///     dict[str, PyPropHistItemsList]:
     fn histories(&self) -> HashMap<ArcStr, PyPropHistItemsList> {
         self.keys()
             .into_iter()
@@ -580,6 +576,13 @@ impl PyTemporalPropsList {
         self.keys().into_iter().into()
     }
 
+    /// Look up a temporal property by key.
+    ///
+    /// Arguments:
+    ///     key (str): property key.
+    ///
+    /// Returns:
+    ///     Optional[PyTemporalPropList]:
     fn get(&self, key: ArcStr) -> Option<PyTemporalPropList> {
         self.__contains__(&key).then(|| {
             let builder = self.builder.clone();
@@ -640,6 +643,10 @@ py_iterable_comp!(
 
 #[pymethods]
 impl PyTemporalPropList {
+    /// Update history (one history per underlying entity).
+    ///
+    /// Returns:
+    ///     HistoryIterable:
     #[getter]
     pub fn history(&self) -> HistoryIterable {
         let builder = self.builder.clone();
@@ -652,21 +659,40 @@ impl PyTemporalPropList {
         .into()
     }
 
+    /// Per-entity list of property values across each entity's history.
+    ///
+    /// Returns:
+    ///     PyPropHistValueList:
     pub fn values(&self) -> PyPropHistValueList {
         let builder = self.builder.clone();
         (move || builder().map(|p| p.map(|v| v.values().collect_vec()).unwrap_or_default())).into()
     }
 
+    /// Per-entity list of `(time, value)` pairs across each entity's history.
+    ///
+    /// Returns:
+    ///     PyPropHistItemsList:
     pub fn items(&self) -> PyPropHistItemsList {
         let builder = self.builder.clone();
         (move || builder().map(|p| p.map(|v| v.iter().collect_vec()).unwrap_or_default())).into()
     }
 
+    /// Value of each entity's property at the given time (latest update at or before `t`).
+    ///
+    /// Arguments:
+    ///     t (TimeInput): the time at which to evaluate the property.
+    ///
+    /// Returns:
+    ///     PyPropValueList:
     pub fn at(&self, t: EventTime) -> PyPropValueList {
         let builder = self.builder.clone();
         (move || builder().map(move |p| p.and_then(|v| v.at(t)))).into()
     }
 
+    /// Latest value of each entity's property.
+    ///
+    /// Returns:
+    ///     PyPropValueList:
     pub fn value(&self) -> PyPropValueList {
         let builder = self.builder.clone();
         (move || builder().map(|p| p.and_then(|v| v.latest()))).into()
@@ -700,8 +726,9 @@ impl From<HashMap<ArcStr, PyTemporalPropListListCmp>> for PyTemporalPropsListLis
     }
 }
 
-impl<'source> FromPyObject<'source> for PyTemporalPropsListListCmp {
-    fn extract_bound(ob: &Bound<'source, PyAny>) -> PyResult<Self> {
+impl<'py> FromPyObject<'_, 'py> for PyTemporalPropsListListCmp {
+    type Error = PyErr;
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
         if let Ok(v) = ob.extract::<PyRef<PyTemporalPropsListList>>() {
             Ok(Self::from(v.deref()))
         } else if let Ok(v) = ob.extract::<HashMap<ArcStr, PyTemporalPropListListCmp>>() {
@@ -716,22 +743,40 @@ py_eq!(PyTemporalPropsListList, PyTemporalPropsListListCmp);
 
 #[pymethods]
 impl PyTemporalPropsListList {
+    /// Property keys present across the underlying entities.
+    ///
+    /// Returns:
+    ///     list[str]:
     fn keys(&self) -> Vec<ArcStr> {
         self.iter()
             .flat_map(|it| it.map(|p| p.keys().collect_vec()))
             .next()
             .unwrap_or_default()
     }
+
+    /// Per-key list of nested temporal property views.
+    ///
+    /// Returns:
+    ///     list[PyTemporalPropListList]:
     fn values(&self) -> Vec<PyTemporalPropListList> {
         self.keys()
             .into_iter()
             .map(|k| self.get(k).expect("key exists"))
             .collect()
     }
+
+    /// Pairs of `(key, nested temporal property list)` for every property key.
+    ///
+    /// Returns:
+    ///     list[tuple[str, PyTemporalPropListList]]:
     fn items(&self) -> Vec<(ArcStr, PyTemporalPropListList)> {
         self.keys().into_iter().zip(self.values()).collect()
     }
 
+    /// Latest value of each property across the nested entities.
+    ///
+    /// Returns:
+    ///     dict[str, PyPropValueListList]:
     fn latest(&self) -> HashMap<ArcStr, PyPropValueListList> {
         let builder = self.builder.clone();
         self.keys()
@@ -754,6 +799,10 @@ impl PyTemporalPropsListList {
             .collect()
     }
 
+    /// Full update history of each property across the nested entities.
+    ///
+    /// Returns:
+    ///     dict[str, PyPropHistItemsListList]:
     fn histories(&self) -> HashMap<ArcStr, PyPropHistItemsListList> {
         let builder = self.builder.clone();
         self.keys()
@@ -793,6 +842,13 @@ impl PyTemporalPropsListList {
         self.keys().into_iter().into()
     }
 
+    /// Look up a nested temporal property by key.
+    ///
+    /// Arguments:
+    ///     key (str): property key.
+    ///
+    /// Returns:
+    ///     Optional[PyTemporalPropListList]:
     fn get(&self, key: ArcStr) -> Option<PyTemporalPropListList> {
         self.__contains__(&key).then(|| {
             let builder = self.builder.clone();
@@ -823,6 +879,10 @@ py_iterable_comp!(
 
 #[pymethods]
 impl PyTemporalPropListList {
+    /// Update history (per outer entity, per inner entity).
+    ///
+    /// Returns:
+    ///     NestedHistoryIterable:
     #[getter]
     pub fn history(&self) -> NestedHistoryIterable {
         let builder = self.builder.clone();
@@ -837,6 +897,10 @@ impl PyTemporalPropListList {
         .into()
     }
 
+    /// Nested list of property values across each inner entity's history.
+    ///
+    /// Returns:
+    ///     PyPropHistValueListList:
     pub fn values(&self) -> PyPropHistValueListList {
         let builder = self.builder.clone();
         (move || {
@@ -845,6 +909,10 @@ impl PyTemporalPropListList {
         .into()
     }
 
+    /// Nested list of `(time, value)` pairs across each inner entity's history.
+    ///
+    /// Returns:
+    ///     PyPropHistItemsListList:
     pub fn items(&self) -> PyPropHistItemsListList {
         let builder = self.builder.clone();
         (move || {
@@ -853,16 +921,31 @@ impl PyTemporalPropListList {
         .into()
     }
 
+    /// Value of each inner entity's property at the given time.
+    ///
+    /// Arguments:
+    ///     t (TimeInput): the time at which to evaluate the property.
+    ///
+    /// Returns:
+    ///     PyPropValueListList:
     pub fn at(&self, t: EventTime) -> PyPropValueListList {
         let builder = self.builder.clone();
         (move || builder().map(move |it| it.map(move |p| p.and_then(|v| v.at(t))))).into()
     }
 
+    /// Latest value of each inner entity's property.
+    ///
+    /// Returns:
+    ///     PyPropValueListList:
     pub fn value(&self) -> PyPropValueListList {
         let builder = self.builder.clone();
         (move || builder().map(|it| it.map(|p| p.and_then(|v| v.latest())))).into()
     }
 
+    /// Flatten the nested temporal property list to a single list of temporal properties.
+    ///
+    /// Returns:
+    ///     PyTemporalPropList:
     pub fn flatten(&self) -> PyTemporalPropList {
         let builder = self.builder.clone();
         (move || builder().flatten()).into()
@@ -871,11 +954,19 @@ impl PyTemporalPropListList {
 
 #[pymethods]
 impl PyPropHistValueListList {
+    /// Flatten the nested history-values list to a single history-values list.
+    ///
+    /// Returns:
+    ///     PyPropHistValueList:
     pub fn flatten(&self) -> PyPropHistValueList {
         let builder = self.builder.clone();
         (move || builder().flatten()).into()
     }
 
+    /// Number of properties (or rows of properties).
+    ///
+    /// Returns:
+    ///     NestedUsizeIterable:
     pub fn count(&self) -> NestedUsizeIterable {
         let builder = self.builder.clone();
         (move || builder().map(|it| it.map(|itit| itit.len()))).into()
@@ -938,6 +1029,10 @@ impl PyPropHistValueListList {
         .into()
     }
 
+    /// Mean property value across each row.
+    ///
+    /// Returns:
+    ///     PyPropValueListList:
     pub fn mean(&self) -> PyPropValueListList {
         let builder = self.builder.clone();
         (move || builder().map(|it| it.map(compute_mean))).into()
@@ -962,6 +1057,10 @@ impl PropIterable {
         compute_median(self.iter().collect())
     }
 
+    /// Number of properties (or rows of properties).
+    ///
+    /// Returns:
+    ///     int:
     pub fn count(&self) -> usize {
         self.iter().count()
     }
@@ -990,6 +1089,10 @@ impl PropIterable {
         self.mean()
     }
 
+    /// Compute the mean of all property values.
+    ///
+    /// Returns:
+    ///     PropValue: The mean of each property values, or None if count is zero.
     pub fn mean(&self) -> PropValue {
         compute_mean(self.iter())
     }
@@ -1036,8 +1139,10 @@ impl PyPropHistValueList {
         .into()
     }
 
+    /// Median property value of each row.
+    ///
     /// Returns:
-    ///     list[PropValue]:
+    ///     PyPropValueList:
     pub fn median(&self) -> PyPropValueList {
         let builder = self.builder.clone();
         (move || builder().map(compute_median)).into()
@@ -1060,11 +1165,19 @@ impl PyPropHistValueList {
         (move || builder().map(compute_mean)).into()
     }
 
+    /// Number of properties (or rows of properties).
+    ///
+    /// Returns:
+    ///     UsizeIterable:
     pub fn count(&self) -> UsizeIterable {
         let builder = self.builder.clone();
         (move || builder().map(|it| it.len())).into()
     }
 
+    /// Flatten the per-row history values into a single iterable of values.
+    ///
+    /// Returns:
+    ///     PropIterable:
     pub fn flatten(&self) -> PropIterable {
         let builder = self.builder.clone();
         (move || builder().flatten()).into()
@@ -1085,6 +1198,10 @@ impl PyPropValueList {
         )
     }
 
+    /// Number of properties (or rows of properties).
+    ///
+    /// Returns:
+    ///     int:
     pub fn count(&self) -> usize {
         self.iter().count()
     }
@@ -1199,31 +1316,47 @@ impl PyPropValueListList {
         self.mean()
     }
 
+    /// Mean property value across each row.
+    ///
+    /// Returns:
+    ///     PyPropValueList:
     pub fn mean(&self) -> PyPropValueList {
         let builder = self.builder.clone();
         (move || builder().map(|it| compute_mean(it.flatten()))).into()
     }
 
+    /// Median property value across each row.
+    ///
     /// Returns:
-    ///     list[PropValue]:
+    ///     PyPropValueList:
     pub fn median(&self) -> PyPropValueList {
         let builder = self.builder.clone();
 
         (move || builder().map(|it| compute_median(it.flatten().collect()))).into()
     }
 
+    /// Flatten the nested iterable into a single list of values.
+    ///
+    /// Returns:
+    ///     PyPropValueList:
     pub fn flatten(&self) -> PyPropValueList {
         let builder = self.builder.clone();
         (move || builder().flatten()).into()
     }
 
+    /// Number of properties (or rows of properties).
+    ///
+    /// Returns:
+    ///     UsizeIterable:
     pub fn count(&self) -> UsizeIterable {
         let builder = self.builder.clone();
         (move || builder().map(|it| it.count())).into()
     }
 
+    /// Drop missing entries from each row.
+    ///
     /// Returns:
-    ///     list[list[PropValue]]:
+    ///     PyPropValueListList:
     pub fn drop_none(&self) -> PyPropValueListList {
         let builder = self.builder.clone();
         (move || builder().map(|it| it.filter(|x| x.is_some()))).into()
diff --git a/raphtory/src/python/graph/views/graph_view.rs b/raphtory/src/python/graph/views/graph_view.rs
index 3df6edfb5f..41c58e3200 100644
--- a/raphtory/src/python/graph/views/graph_view.rs
+++ b/raphtory/src/python/graph/views/graph_view.rs
@@ -39,10 +39,10 @@ use crate::{
         utils::PyNodeRef,
     },
 };
-use pyo3::prelude::*;
+use pyo3::{prelude::*, Borrowed};
 use raphtory_api::{core::storage::arc_str::ArcStr, python::timeindex::PyOptionalEventTime};
 use rayon::prelude::*;
-use std::collections::HashMap;
+use std::{collections::HashMap, path::PathBuf};
 
 impl<'py> IntoPyObject<'py> for MaterializedGraph {
     type Target = PyAny;
@@ -67,9 +67,10 @@ impl<'py> IntoPyObject<'py> for DynamicGraph {
     }
 }
 
-impl<'source> FromPyObject<'source> for DynamicGraph {
-    fn extract_bound(ob: &Bound<'source, PyAny>) -> PyResult<Self> {
-        ob.extract::<PyRef<PyGraphView>>().map(|g| g.graph.clone())
+impl<'py> FromPyObject<'_, 'py> for DynamicGraph {
+    type Error = PyErr;
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
+        Ok(ob.extract::<PyRef<PyGraphView>>()?.graph.clone())
     }
 }
 /// Graph view is a read-only version of a graph at a certain point in time.
@@ -419,7 +420,8 @@ impl PyGraphView {
         self.graph.exclude_nodes(nodes)
     }
 
-    /// Returns a 'materialized' clone of the graph view - i.e. a new graph with a copy of the data seen within the view instead of just a mask over the original graph
+    /// Returns a 'materialized' clone of the graph view - i.e. a new graph with a
+    /// copy of the data seen within the view instead of just a mask over the original graph.
     ///
     /// Returns:
     ///    GraphView: Returns a graph clone
@@ -427,6 +429,17 @@ impl PyGraphView {
         self.graph.materialize()
     }
 
+    /// Materializes the graph view into a folder on disk.
+    ///
+    /// Arguments:
+    ///     path (str | PathLike): destination folder for the materialised graph.
+    ///
+    /// Returns:
+    ///     GraphView: the materialised graph at `path`.
+    fn materialize_at(&self, path: PathBuf) -> Result<MaterializedGraph, GraphError> {
+        self.graph.materialize_at(&path)
+    }
+
     /// Displays the graph
     pub fn __repr__(&self) -> String {
         self.repr()
diff --git a/raphtory/src/python/mod.rs b/raphtory/src/python/mod.rs
index aaec060e8b..9382ead352 100644
--- a/raphtory/src/python/mod.rs
+++ b/raphtory/src/python/mod.rs
@@ -3,6 +3,7 @@ extern crate core;
 #[macro_use]
 pub mod types;
 mod algorithm;
+pub mod config;
 pub mod filter;
 pub mod graph;
 pub mod packages;
diff --git a/raphtory/src/python/packages/algorithms.rs b/raphtory/src/python/packages/algorithms.rs
index d09bf4f6d8..b8d3043287 100644
--- a/raphtory/src/python/packages/algorithms.rs
+++ b/raphtory/src/python/packages/algorithms.rs
@@ -1,7 +1,5 @@
 #![allow(non_snake_case)]
 
-#[cfg(feature = "storage")]
-use crate::python::graph::disk_graph::PyDiskGraph;
 use crate::{
     algorithms::{
         alternating_mask::alternating_mask as alternating_mask_rs,
@@ -73,11 +71,9 @@ use crate::{
         utils::PyNodeRef,
     },
 };
-#[cfg(feature = "storage")]
-use pometry_storage::algorithms::connected_components::connected_components as connected_components_rs;
 use pyo3::{prelude::*, types::PyList};
 use rand::{prelude::StdRng, SeedableRng};
-use raphtory_api::core::{storage::timeindex::EventTime, Direction};
+use raphtory_api::core::{entities::LayerIds, storage::timeindex::EventTime, Direction};
 use raphtory_storage::core_ops::CoreGraphOps;
 
 /// Helper function to parse single-vertex or multi-vertex parameters to a Vec of vertices
@@ -91,7 +87,7 @@ fn process_node_param(param: &Bound<PyAny>) -> PyResult<Vec<PyNodeRef>> {
         return Ok(vec![single_node]);
     }
 
-    if let Ok(py_list) = param.downcast::<PyList>() {
+    if let Ok(py_list) = param.cast::<PyList>() {
         let mut nodes = Vec::new();
         for item in py_list.iter() {
             let num = item.extract::<PyNodeRef>()?;
@@ -153,7 +149,7 @@ pub fn weakly_connected_components(
 ///     graph (GraphView): Raphtory graph
 ///
 /// Returns:
-///     PyOutputNodeState: NodeState mapping nodes to their component ids
+///     OutputNodeState: NodeState mapping nodes to their component ids
 #[pyfunction]
 #[pyo3(signature = (graph))]
 pub fn strongly_connected_components(
@@ -162,13 +158,6 @@ pub fn strongly_connected_components(
     components::strongly_connected_components(&graph.graph).to_output_nodestate()
 }
 
-#[cfg(feature = "storage")]
-#[pyfunction]
-#[pyo3(signature = (graph))]
-pub fn connected_components(graph: &PyDiskGraph) -> Vec<usize> {
-    connected_components_rs(graph.0.as_ref())
-}
-
 /// In components -- Finding the "in-component" of a node in a directed graph involves identifying all nodes that can be reached following only incoming edges.
 ///
 /// Arguments:
@@ -269,7 +258,7 @@ pub fn out_component(
 ///     damping_factor (float): The damping factor for the PageRank calculation. Defaults to 0.85.
 ///
 /// Returns:
-///     PyOutputNodeState: NodeState mapping nodes to their pagerank score.
+///     OutputNodeState: NodeState mapping nodes to their pagerank score.
 #[pyfunction]
 #[pyo3(signature = (graph, iter_count=20, max_diff=None, use_l2_norm=true, damping_factor=0.85))]
 pub fn pagerank(
@@ -349,7 +338,7 @@ pub fn local_clustering_coefficient(graph: &PyGraphView, v: PyNodeRef) -> Option
 ///     v: vec of node ids, if empty, will return results for every node in the graph
 ///
 /// Returns:
-///     PyOutputNodeState: Mapping of vertices to lcc score
+///     OutputNodeState: Mapping of vertices to lcc score
 #[pyfunction]
 #[pyo3(signature = (graph, v=None))]
 pub fn local_clustering_coefficient_batch(
@@ -604,6 +593,7 @@ pub fn global_temporal_three_node_motif_multi(
 /// Arguments:
 ///     graph (GraphView): A directed raphtory graph
 ///     delta (int): Maximum time difference between the first and last edge of the motif. NB if time for edges was given as a UNIX epoch, this should be given in seconds, otherwise milliseconds should be used (if edge times were given as string)
+///     threads (int, optional): Number of threads to use. Defaults to None.
 ///
 /// Returns:
 ///     NodeStateMotifs: A mapping from nodes to lists of motif counts (40 counts in the same order as the global motif counts) with the number of each motif that node participates in.
@@ -679,7 +669,7 @@ pub fn balance(
 ///     graph (GraphView): The graph view on which the operation is to be performed.
 ///
 /// Returns:
-///     PyOutputNodeState: NodeState mapping nodes to their associated degree centrality.
+///     OutputNodeState: NodeState mapping nodes to their associated degree centrality.
 #[pyfunction]
 #[pyo3[signature = (graph)]]
 pub fn degree_centrality(graph: &PyGraphView) -> OutputTypedNodeState<'static, DynamicGraph> {
@@ -781,11 +771,11 @@ pub fn betweenness_centrality(
 ///
 /// Arguments:
 ///     graph (GraphView): A reference to the graph
-///     iter_count: Number of iterations
+///     iter_count (int): Number of iterations. Defaults to 20.
 ///     seed (bytes, optional): Array of 32 bytes of u8 which is set as the rng seed
 ///
 /// Returns:
-///     PyOutputNodeState: NodeState mapping nodes to community id
+///     OutputNodeState: NodeState mapping nodes to community id
 ///
 #[pyfunction]
 #[pyo3[signature = (graph, iter_count=20, seed=None)]]
@@ -821,10 +811,10 @@ pub fn k_core(
     threads: Option<usize>,
 ) -> Nodes<'static, DynamicGraph> {
     let v_set = k_core_set(&graph.graph, k, iter_count, threads);
-    let index = if v_set.len() == graph.graph.unfiltered_num_nodes() {
-        None
+    let index = if v_set.len() == graph.graph.unfiltered_num_nodes(&LayerIds::All) {
+        Index::for_graph(graph.graph.clone())
     } else {
-        Some(Index::from_iter(v_set))
+        Index::from_iter(v_set)
     };
     Nodes::new_filtered(graph.graph.clone(), graph.graph.clone(), NO_FILTER, index)
 }
@@ -867,7 +857,7 @@ pub fn temporal_SEIR(
     rng_seed: Option<u64>,
 ) -> Result<OutputTypedNodeState<'static, DynamicGraph>, SeedError> {
     let mut rng = match rng_seed {
-        None => StdRng::from_entropy(),
+        None => StdRng::from_os_rng(),
         Some(seed) => StdRng::seed_from_u64(seed),
     };
     temporal_SEIR_rs(
@@ -1000,7 +990,7 @@ pub fn temporal_rich_club_coefficient(
 ) -> PyResult<f64> {
     let py_iterator = views.try_iter()?;
     let views = py_iterator
-        .map(|view| view.and_then(|view| Ok(view.downcast::<PyGraphView>()?.get().graph.clone())))
+        .map(|view| view.and_then(|view| Ok(view.cast::<PyGraphView>()?.get().graph.clone())))
         .collect::<PyResult<Vec<_>>>()?;
     Ok(temporal_rich_club_rs(&graph.graph, views, k, window_size))
 }
@@ -1093,7 +1083,7 @@ pub fn fast_rp(
 ///     graph (GraphView): The graph view on which the operation is to be performed.
 ///
 /// Returns:
-///     PyOutputNodeState: NodeState mapping nodes to their associated alternating masks.
+///     OutputNodeState: NodeState mapping nodes to their associated alternating masks.
 #[pyfunction]
 #[pyo3[signature = (graph)]]
 pub fn alternating_mask(graph: &PyGraphView) -> OutputTypedNodeState<'static, DynamicGraph> {
diff --git a/raphtory/src/python/packages/base_modules.rs b/raphtory/src/python/packages/base_modules.rs
index 5b88faacea..23e183b73f 100644
--- a/raphtory/src/python/packages/base_modules.rs
+++ b/raphtory/src/python/packages/base_modules.rs
@@ -1,7 +1,4 @@
 //ALGORITHMS
-
-#[cfg(feature = "storage")]
-use crate::python::graph::disk_graph::PyDiskGraph;
 use crate::{
     add_classes, add_functions,
     python::{
@@ -18,11 +15,13 @@ use crate::{
                 NestedHistoryTimestampIterable, NestedIntervalsIterable, PyHistory,
                 PyHistoryDateTime, PyHistoryEventId, PyHistoryTimestamp, PyIntervals,
             },
-            index::{PyIndexSpec, PyIndexSpecBuilder},
             node::{PyMutableNode, PyNode, PyNodes, PyPathFromGraph, PyPathFromNode},
             properties::{
-                MetadataView, PropertiesView, PyMetadata, PyPropValueList, PyProperties,
-                PyTemporalProp, PyTemporalProperties,
+                MetadataView, PropertiesView, PyMetadata, PyPropHistItemsList,
+                PyPropHistItemsListList, PyPropHistValueList, PyPropHistValueListList,
+                PyPropValueList, PyPropValueListList, PyProperties, PyTemporalProp,
+                PyTemporalPropList, PyTemporalPropListList, PyTemporalProperties,
+                PyTemporalPropsList, PyTemporalPropsListList,
             },
             views::graph_view::PyGraphView,
         },
@@ -31,8 +30,8 @@ use crate::{
             graph_gen::*,
             graph_loader::*,
             vectors::{
-                embedding_server, PyOpenAIEmbeddings, PyVectorCache, PyVectorSelection,
-                PyVectorisedGraph,
+                embedding_server, PyEmbeddingServer, PyOpenAIEmbeddings, PyRunningEmbeddingServer,
+                PyVectorCache, PyVectorSelection, PyVectorisedGraph,
             },
         },
         types::{
@@ -53,7 +52,7 @@ use crate::{
                     NestedUtcDateTimeIterable, NestedVecUtcDateTimeIterable,
                     OptionArcStringIterable, OptionEventTimeIterable, OptionI64Iterable,
                     OptionUsizeIterable, OptionUtcDateTimeIterable, OptionVecUtcDateTimeIterable,
-                    StringIterable, U64Iterable, UsizeIterable,
+                    PropIterable, StringIterable, U64Iterable, UsizeIterable,
                 },
             },
         },
@@ -67,6 +66,9 @@ use raphtory_api::python::{
     PyProp,
 };
 
+#[cfg(feature = "search")]
+use crate::python::graph::index::{PyIndexSpec, PyIndexSpecBuilder};
+
 pub fn add_raphtory_classes(m: &Bound<PyModule>) -> PyResult<()> {
     //Graph classes
     add_classes!(
@@ -100,11 +102,12 @@ pub fn add_raphtory_classes(m: &Bound<PyModule>) -> PyResult<()> {
         PyHistoryEventId,
         PyIntervals,
         PyWindowSet,
-        PyIndexSpecBuilder,
-        PyIndexSpec,
         PyProp
     );
 
+    #[cfg(feature = "search")]
+    add_classes!(m, PyIndexSpecBuilder, PyIndexSpec);
+
     #[pyfunction]
     /// Return Raphtory version.
     ///
@@ -116,8 +119,6 @@ pub fn add_raphtory_classes(m: &Bound<PyModule>) -> PyResult<()> {
 
     m.add_function(wrap_pyfunction!(version, m)?)?;
 
-    #[cfg(feature = "storage")]
-    add_classes!(m, PyDiskGraph);
     Ok(())
 }
 
@@ -173,6 +174,16 @@ pub fn base_iterables_module(py: Python<'_>) -> Result<Bound<'_, PyModule>, PyEr
         NestedResultUtcDateTimeIterable,
         MetadataListList,
         PyNestedPropsIterable,
+        PyPropValueListList,
+        PyTemporalPropsList,
+        PyTemporalPropsListList,
+        PyPropHistValueList,
+        PyPropHistValueListList,
+        PyTemporalPropList,
+        PyTemporalPropListList,
+        PyPropHistItemsList,
+        PyPropHistItemsListList,
+        PropIterable,
     );
     Ok(iterables_module)
 }
@@ -226,8 +237,6 @@ pub fn base_algorithm_module(py: Python<'_>) -> Result<Bound<'_, PyModule>, PyEr
     );
 
     add_classes!(&algorithm_module, PyMatching, PyInfected);
-    #[cfg(feature = "storage")]
-    add_functions!(&algorithm_module, connected_components);
     Ok(algorithm_module)
 }
 
@@ -266,6 +275,8 @@ pub fn base_vectors_module(py: Python<'_>) -> Result<Bound<'_, PyModule>, PyErr>
         PyVectorSelection,
         PyOpenAIEmbeddings,
         PyVectorCache,
+        PyEmbeddingServer,
+        PyRunningEmbeddingServer,
     );
     add_functions!(&vectors_module, embedding_server);
     Ok(vectors_module)
diff --git a/raphtory/src/python/packages/graph_gen.rs b/raphtory/src/python/packages/graph_gen.rs
index a822065e2e..0ee8e6f8ff 100644
--- a/raphtory/src/python/packages/graph_gen.rs
+++ b/raphtory/src/python/packages/graph_gen.rs
@@ -23,7 +23,7 @@ use pyo3::prelude::*;
 ///   seed: The seed used in rng, an array of length 32 containing ints (ints must have a max size of u8)
 ///
 /// Returns:
-///  None
+///  None:
 #[pyfunction]
 #[pyo3[signature = (g, nodes_to_add, edges_per_step, seed=None)]]
 pub fn random_attachment(
@@ -55,8 +55,7 @@ pub fn random_attachment(
 ///    seed: The seed used in rng, an array of length 32 containing ints (ints must have a max size of u8)
 ///
 /// Returns:
-///
-/// None
+///     None:
 #[pyfunction]
 #[pyo3[signature = (g, nodes_to_add, edges_per_step, seed=None)]]
 pub fn ba_preferential_attachment(
diff --git a/raphtory/src/python/packages/graph_loader.rs b/raphtory/src/python/packages/graph_loader.rs
index cb905931b0..80dc7b5703 100644
--- a/raphtory/src/python/packages/graph_loader.rs
+++ b/raphtory/src/python/packages/graph_loader.rs
@@ -119,7 +119,7 @@ pub fn stable_coin_graph(path: Option<String>, subset: Option<bool>) -> PyResult
 ///     uri (str):
 ///     username (str):
 ///     password (str):
-///     database (str):
+///     database (str): Neo4j database name. Defaults to "neo4j".
 ///
 /// Returns:
 ///     Graph:
diff --git a/raphtory/src/python/packages/vectors.rs b/raphtory/src/python/packages/vectors.rs
index 14b3aa064e..bff88c7758 100644
--- a/raphtory/src/python/packages/vectors.rs
+++ b/raphtory/src/python/packages/vectors.rs
@@ -23,6 +23,7 @@ use pyo3::{
     exceptions::{PyException, PyTypeError},
     prelude::*,
     types::{PyFunction, PyList},
+    Borrowed,
 };
 use raphtory_api::core::{
     storage::timeindex::{AsTime, EventTime},
@@ -33,6 +34,16 @@ use tokio::runtime::Runtime;
 
 type DynamicVectorisedGraph = VectorisedGraph<DynamicGraph>;
 
+/// OpenAI-compatible embedding configuration. Pass an instance of this to
+/// `VectorCache(...)` to drive `vectorise(...)`.
+///
+/// Arguments:
+///     model (str): The OpenAI embedding model to use. Defaults to "text-embedding-3-small".
+///     api_base (str, optional): Base URL for the OpenAI-compatible API. If None, falls back to OpenAI's default endpoint. Defaults to None.
+///     api_key_env (str, optional): Environment variable name to read the API key from. If None, reads from `OPENAI_API_KEY`. Defaults to None.
+///     org_id (str, optional): OpenAI organization id. If None, no org id is sent. Defaults to None.
+///     project_id (str, optional): OpenAI project id. If None, no project id is sent. Defaults to None.
+///     dim (int, optional): Embedding dimension override. If None, the model's native dimension is used. Defaults to None.
 #[pyclass(name = "OpenAIEmbeddings")]
 #[derive(Clone)]
 pub struct PyOpenAIEmbeddings {
@@ -79,6 +90,12 @@ impl From<PyOpenAIEmbeddings> for OpenAIEmbeddings {
     }
 }
 
+/// Cache wrapping an embedding model. Pass to `Graph.vectorise(model=...)`
+/// or other vectorisation entry points.
+///
+/// Arguments:
+///     v_cache (OpenAIEmbeddings): Embedding model configuration.
+///     cache (str, optional): Path to persist the embedding cache on disk. Defaults to None.
 #[pyclass(name = "VectorCache")]
 #[derive(Clone)]
 pub struct PyVectorCache {
@@ -105,15 +122,23 @@ impl PyVectorCache {
 
 impl EmbeddingFunction for Arc<Py<PyFunction>> {
     fn call(&self, text: &str) -> Vec<f32> {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             // TODO: remove unwraps?
             let any = self.call1(py, (text,)).unwrap();
-            let list = any.downcast_bound::<PyList>(py).unwrap();
+            let list = any.cast_bound::<PyList>(py).unwrap();
             list.iter().map(|value| value.extract().unwrap()).collect()
         })
     }
 }
 
+/// Wrap a Python callable so it can be served as an OpenAI-compatible
+/// embedding endpoint via `EmbeddingServer.serve(...)`.
+///
+/// Arguments:
+///     function (Callable[[str], list[float]]): A callable that maps a text input to its embedding vector.
+///
+/// Returns:
+///     EmbeddingServer:
 #[pyfunction]
 pub fn embedding_server(function: Py<PyFunction>) -> PyEmbeddingServer {
     PyEmbeddingServer {
@@ -142,12 +167,28 @@ impl PyEmbeddingServer {
 
 #[pymethods]
 impl PyEmbeddingServer {
+    /// Run the embedding server in the foreground until it's stopped.
+    ///
+    /// Arguments:
+    ///     port (int): Port to listen on.
+    ///     host (str, optional): Host interface to bind to. Defaults to None.
+    ///
+    /// Returns:
+    ///     None:
     #[pyo3(signature = (port, host=None))]
     fn run(&self, port: u16, host: Option<&str>) {
         let (runtime, execution) = self.create_running_server(host, port);
         runtime.block_on(execution.wait());
     }
 
+    /// Start the embedding server in the background and return a handle.
+    ///
+    /// Arguments:
+    ///     port (int): Port to listen on.
+    ///     host (str, optional): Host interface to bind to. Defaults to None.
+    ///
+    /// Returns:
+    ///     RunningEmbeddingServer: handle to stop the server.
     #[pyo3(signature = (port, host=None))]
     fn start(&self, port: u16, host: Option<&str>) -> PyRunningEmbeddingServer {
         let (runtime, execution) = self.create_running_server(host, port);
@@ -159,13 +200,17 @@ impl PyEmbeddingServer {
 }
 
 #[pyclass(name = "RunningEmbeddingServer")]
-struct PyRunningEmbeddingServer {
+pub struct PyRunningEmbeddingServer {
     runtime: Runtime,
     execution: Option<EmbeddingServer>, // TODO: rename EmbeddingServer to ServerHandle?
 }
 
 #[pymethods]
 impl PyRunningEmbeddingServer {
+    /// Stop the running embedding server.
+    ///
+    /// Returns:
+    ///     None:
     fn stop(&mut self) -> PyResult<()> {
         if let Some(execution) = &mut self.execution {
             self.runtime.block_on(execution.stop());
@@ -183,9 +228,9 @@ impl PyRunningEmbeddingServer {
     fn __exit__(
         &mut self,
         // py: Python,
-        _exc_type: PyObject,
-        _exc_val: PyObject,
-        _exc_tb: PyObject,
+        _exc_type: Py<PyAny>,
+        _exc_val: Py<PyAny>,
+        _exc_tb: Py<PyAny>,
     ) -> PyResult<()> {
         self.stop()
     }
@@ -221,15 +266,16 @@ impl PyQuery {
     }
 }
 
-impl<'source> FromPyObject<'source> for PyQuery {
-    fn extract_bound(query: &Bound<'source, PyAny>) -> PyResult<Self> {
+impl<'py> FromPyObject<'_, 'py> for PyQuery {
+    type Error = PyErr;
+    fn extract(query: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
         if let Ok(text) = query.extract::<String>() {
             return Ok(PyQuery::Raw(text));
         }
         if let Ok(embedding) = query.extract::<Vec<f32>>() {
             return Ok(PyQuery::Computed(embedding.into()));
         }
-        let message = format!("query '{query}' must be a str, or a list of float");
+        let message = format!("query '{query:?}' must be a str, or a list of float");
         Err(PyTypeError::new_err(message))
     }
 }
@@ -303,10 +349,9 @@ impl PyGraphView {
     /// Create a VectorisedGraph from the current graph.
     ///
     /// Args:
-    ///   embedding (Callable[[list], list]): Specify the embedding function used to vectorise documents into embeddings.
+    ///   model (VectorCache): Cache wrapping the embedding model used to embed documents.
     ///   nodes (bool | str): Enable for nodes to be embedded, disable for nodes to not be embedded or specify a custom document property to use if a string is provided. Defaults to True.
     ///   edges (bool | str): Enable for edges to be embedded, disable for edges to not be embedded or specify a custom document property to use if a string is provided. Defaults to True.
-    ///   cache (str, optional): Path used to store the cache of embeddings.
     ///   verbose (bool): Enable to print logs reporting progress. Defaults to False.
     ///
     /// Returns:
@@ -372,12 +417,18 @@ impl<'py> IntoPyObject<'py> for DynamicVectorSelection {
 /// of those documents using a query and similarity scores.
 #[pymethods]
 impl PyVectorisedGraph {
-    /// Optmize the vector index
+    /// Optimise the vector index.
+    ///
+    /// Returns:
+    ///     None:
     fn optimize_index(&self) -> PyResult<()> {
         Ok(block_on(self.0.optimize_index())?)
     }
 
     /// Return an empty selection of entities.
+    ///
+    /// Returns:
+    ///     VectorSelection:
     fn empty_selection(&self) -> DynamicVectorSelection {
         self.0.empty_selection()
     }
diff --git a/raphtory/src/python/types/iterable.rs b/raphtory/src/python/types/iterable.rs
index cc9e923413..4bef0535a5 100644
--- a/raphtory/src/python/types/iterable.rs
+++ b/raphtory/src/python/types/iterable.rs
@@ -2,7 +2,7 @@ use crate::{
     db::api::view::BoxedIter,
     python::types::repr::{iterator_repr, Repr},
 };
-use pyo3::prelude::*;
+use pyo3::{prelude::*, types::PyAnyMethods, Borrowed};
 use std::{
     marker::PhantomData,
     ops::{Deref, DerefMut},
@@ -153,15 +153,17 @@ impl<T> IntoIterator for FromIterable<T> {
     }
 }
 
-impl<'py, T: FromPyObject<'py>> FromPyObject<'py> for FromIterable<T> {
-    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
-        let len = ob.len().unwrap_or(0);
-        let mut vec = Vec::<T>::with_capacity(len);
-        {
-            for value in ob.try_iter()? {
-                vec.push(value?.extract()?)
-            }
+impl<'py, T> FromPyObject<'_, 'py> for FromIterable<T>
+where
+    T: FromPyObjectOwned<'py>,
+{
+    type Error = PyErr;
+
+    fn extract(obj: Borrowed<'_, 'py, PyAny>) -> Result<Self, Self::Error> {
+        let mut v = FromIterable(Vec::new());
+        for item in obj.try_iter()? {
+            v.0.push(item?.extract::<T>().map_err(Into::into)?);
         }
-        Ok(Self(vec))
+        Ok(v)
     }
 }
diff --git a/raphtory/src/python/types/macros/borrowing_iterator.rs b/raphtory/src/python/types/macros/borrowing_iterator.rs
index 8743ec05fa..f0369b5be6 100644
--- a/raphtory/src/python/types/macros/borrowing_iterator.rs
+++ b/raphtory/src/python/types/macros/borrowing_iterator.rs
@@ -4,13 +4,16 @@ macro_rules! py_borrowing_iter {
         struct Iterator($inner_t);
 
         impl $crate::python::types::wrappers::iterators::PyIter for Iterator {
-            fn iter(&self) -> $crate::db::api::view::BoxedLIter<'_, PyResult<PyObject>> {
+            fn iter(
+                &self,
+            ) -> $crate::db::api::view::BoxedLIter<'_, PyResult<pyo3::Py<pyo3::PyAny>>>
+            {
                 // forces the type inference to return the correct lifetimes,
                 // calling the closure directly does not work
                 fn apply<'a, O: $crate::python::types::wrappers::iterators::IntoPyIter<'a>>(
                     arg: &'a $inner_t,
                     f: impl FnOnce(&'a $inner_t) -> O,
-                ) -> $crate::db::api::view::BoxedLIter<'a, PyResult<pyo3::PyObject>>
+                ) -> $crate::db::api::view::BoxedLIter<'a, PyResult<pyo3::Py<pyo3::PyAny>>>
                 {
                     $crate::python::types::wrappers::iterators::IntoPyIter::into_py_iter(f(arg))
                 }
@@ -28,13 +31,13 @@ macro_rules! py_borrowing_iter_result {
         struct Iterator($inner_t);
 
         impl $crate::python::types::wrappers::iterators::PyIter for Iterator {
-            fn iter(&self) -> $crate::db::api::view::BoxedLIter<'_, PyResult<PyObject>> {
+            fn iter(&self) -> $crate::db::api::view::BoxedLIter<'_, PyResult<Py<PyAny>>> {
                 // forces the type inference to return the correct lifetimes,
                 // calling the closure directly does not work
                 fn apply<'a, O: $crate::python::types::wrappers::iterators::IntoPyIterResult<'a>>(
                     arg: &'a $inner_t,
                     f: impl FnOnce(&'a $inner_t) -> O,
-                ) -> $crate::db::api::view::BoxedLIter<'a, PyResult<pyo3::PyObject>>
+                ) -> $crate::db::api::view::BoxedLIter<'a, PyResult<pyo3::Py<pyo3::PyAny>>>
                 {
                     $crate::python::types::wrappers::iterators::IntoPyIterResult::into_py_iter_result(f(arg))
                 }
@@ -52,13 +55,13 @@ macro_rules! py_borrowing_iter_tuple_result {
         struct Iterator($inner_t);
 
         impl $crate::python::types::wrappers::iterators::PyIter for Iterator {
-            fn iter(&self) -> $crate::db::api::view::BoxedLIter<'_, PyResult<PyObject>> {
+            fn iter(&self) -> $crate::db::api::view::BoxedLIter<'_, PyResult<Py<PyAny>>> {
                 // forces the type inference to return the correct lifetimes,
                 // calling the closure directly does not work
                 fn apply<'a, O: $crate::python::types::wrappers::iterators::IntoPyIterTupleResult<'a>>(
                     arg: &'a $inner_t,
                     f: impl FnOnce(&'a $inner_t) -> O,
-                ) -> $crate::db::api::view::BoxedLIter<'a, PyResult<pyo3::PyObject>>
+                ) -> $crate::db::api::view::BoxedLIter<'a, PyResult<pyo3::Py<pyo3::PyAny>>>
                 {
                     $crate::python::types::wrappers::iterators::IntoPyIterTupleResult::into_py_iter_tuple_result(f(arg))
                 }
diff --git a/raphtory/src/python/types/macros/iterable.rs b/raphtory/src/python/types/macros/iterable.rs
index cc9f2dcd99..9033c306da 100644
--- a/raphtory/src/python/types/macros/iterable.rs
+++ b/raphtory/src/python/types/macros/iterable.rs
@@ -3,11 +3,19 @@ macro_rules! _py_numeric_methods {
     ($name:ident, $item:ty, $pyitem:ty) => {
         #[pymethods]
         impl $name {
+            /// Sum of all values in the iterable.
+            ///
+            /// Returns:
+            ///     Any:
             pub fn sum(&self) -> $pyitem {
                 let v: $item = self.iter().sum();
                 v.into()
             }
 
+            /// Mean of all values in the iterable.
+            ///
+            /// Returns:
+            ///     float:
             pub fn mean(&self) -> f64 {
                 use $crate::python::types::wrappers::iterables::MeanExt;
                 self.iter().mean()
@@ -21,10 +29,18 @@ macro_rules! _py_ord_max_min_methods {
     ($name:ident, $pyitem:ty) => {
         #[pymethods]
         impl $name {
+            /// Maximum value in the iterable, or `None` if empty.
+            ///
+            /// Returns:
+            ///     Any:
             pub fn max(&self) -> Option<$pyitem> {
                 self.iter().max().map(|v| v.into())
             }
 
+            /// Minimum value in the iterable, or `None` if empty.
+            ///
+            /// Returns:
+            ///     Any:
             pub fn min(&self) -> Option<$pyitem> {
                 self.iter().min().map(|v| v.into())
             }
@@ -37,9 +53,17 @@ macro_rules! _py_float_max_min_methods {
     ($name:ident, $pyitem:ty) => {
         #[pymethods]
         impl $name {
+            /// Maximum value in the iterable, or `None` if empty.
+            ///
+            /// Returns:
+            ///     Any:
             pub fn max(&self) -> Option<$pyitem> {
                 self.iter().max_by(|a, b| a.total_cmp(b)).map(|v| v.into())
             }
+            /// Minimum value in the iterable, or `None` if empty.
+            ///
+            /// Returns:
+            ///     Any:
             pub fn min(&self) -> Option<$pyitem> {
                 self.iter().min_by(|a, b| a.total_cmp(b)).map(|v| v.into())
             }
@@ -72,6 +96,10 @@ macro_rules! _py_iterable_collect_method {
     ($name:ident, $pyitem:ty) => {
         #[pymethods]
         impl $name {
+            /// Materialise the iterable as a Python list.
+            ///
+            /// Returns:
+            ///     list:
             pub fn collect(&self) -> Vec<$pyitem> {
                 self.iter().map(|v| v.into()).collect()
             }
@@ -227,13 +255,14 @@ macro_rules! py_iterable_comp {
             fn clone(&self) -> Self {
                 match self {
                     Self::Vec(v) => Self::Vec(v.clone()),
-                    Self::This(v) => Self::This(Python::with_gil(|py| v.clone_ref(py))),
+                    Self::This(v) => Self::This(Python::attach(|py| v.clone_ref(py))),
                 }
             }
         }
 
-        impl<'source> FromPyObject<'source> for $cmp_internal {
-            fn extract_bound(ob: &Bound<'source, PyAny>) -> PyResult<Self> {
+        impl<'source> FromPyObject<'_, 'source> for $cmp_internal {
+            type Error = PyErr;
+            fn extract(ob: Borrowed<'_, 'source, PyAny>) -> PyResult<Self> {
                 if let Ok(s) = ob.extract::<Py<$name>>() {
                     Ok($cmp_internal::This(s))
                 } else if let Ok(v) = ob.extract::<Vec<$cmp_item>>() {
@@ -246,7 +275,7 @@ macro_rules! py_iterable_comp {
 
         impl From<$name> for $cmp_internal {
             fn from(value: $name) -> Self {
-                let py_value = Python::with_gil(|py| Py::new(py, value)).unwrap();
+                let py_value = Python::attach(|py| Py::new(py, value)).unwrap();
                 Self::This(py_value)
             }
         }
@@ -265,7 +294,7 @@ macro_rules! py_iterable_comp {
 
         impl PartialEq for $cmp_internal {
             fn eq(&self, other: &Self) -> bool {
-                Python::with_gil(|py| self.iter_py(py).eq(other.iter_py(py)))
+                Python::attach(|py| self.iter_py(py).eq(other.iter_py(py)))
             }
         }
 
diff --git a/raphtory/src/python/types/macros/nested_iterable.rs b/raphtory/src/python/types/macros/nested_iterable.rs
index bd756aab91..b002244d70 100644
--- a/raphtory/src/python/types/macros/nested_iterable.rs
+++ b/raphtory/src/python/types/macros/nested_iterable.rs
@@ -38,6 +38,10 @@ macro_rules! _py_nested_iterable_methods {
 
         #[pymethods]
         impl $name {
+            /// Materialise the nested iterable as a list of lists.
+            ///
+            /// Returns:
+            ///     list[list]:
             pub fn collect(&self) -> Vec<Vec<$pyitem>> {
                 self.iter()
                     .map(|it| it.map(|v| v.into()).collect())
@@ -52,6 +56,10 @@ macro_rules! _py_nested_numeric_methods {
     ($name:ident, $item:ty, $value_iterable:ty) => {
         #[pymethods]
         impl $name {
+            /// Per-row sum of values (one entry per outer row).
+            ///
+            /// Returns:
+            ///     Any:
             pub fn sum(&self) -> $value_iterable {
                 let builder = self.builder.clone();
                 (move || {
@@ -61,6 +69,10 @@ macro_rules! _py_nested_numeric_methods {
                 .into()
             }
 
+            /// Per-row mean of values (one entry per outer row).
+            ///
+            /// Returns:
+            ///     Any:
             pub fn mean(&self) -> Float64Iterable {
                 let builder = self.builder.clone();
                 (move || {
@@ -78,6 +90,10 @@ macro_rules! _py_nested_ord_max_min_methods {
     ($name:ident, $item:ty, $option_value_iterable:ty) => {
         #[pymethods]
         impl $name {
+            /// Per-row maximum value (or None for empty rows).
+            ///
+            /// Returns:
+            ///     Any:
             fn max(&self) -> $option_value_iterable {
                 let builder = self.builder.clone();
                 (move || {
@@ -87,6 +103,10 @@ macro_rules! _py_nested_ord_max_min_methods {
                 .into()
             }
 
+            /// Per-row minimum value (or None for empty rows).
+            ///
+            /// Returns:
+            ///     Any:
             fn min(&self) -> $option_value_iterable {
                 let builder = self.builder.clone();
                 (move || {
@@ -104,6 +124,10 @@ macro_rules! _py_nested_float_max_min_methods {
     ($name:ident, $item:ty, $option_value_iterable:ty) => {
         #[pymethods]
         impl $name {
+            /// Per-row maximum value (or None for empty rows).
+            ///
+            /// Returns:
+            ///     Any:
             fn max(&self) -> $option_value_iterable {
                 let builder = self.builder.clone();
                 (move || {
@@ -114,6 +138,10 @@ macro_rules! _py_nested_float_max_min_methods {
                 .into()
             }
 
+            /// Per-row minimum value (or None for empty rows).
+            ///
+            /// Returns:
+            ///     Any:
             fn min(&self) -> $option_value_iterable {
                 let builder = self.builder.clone();
                 (move || {
diff --git a/raphtory/src/python/types/macros/trait_impl/serialise.rs b/raphtory/src/python/types/macros/trait_impl/serialise.rs
index 96aee63bf0..bc0bfab9d3 100644
--- a/raphtory/src/python/types/macros/trait_impl/serialise.rs
+++ b/raphtory/src/python/types/macros/trait_impl/serialise.rs
@@ -9,44 +9,7 @@ macro_rules! impl_serialise {
     ($obj:ty, $field:ident: $base_type:ty, $name:literal) => {
         #[pyo3::pymethods]
         impl $obj {
-            #[doc = concat!(" Write ", $name, " to cache file and initialise the cache.")]
-            ///
-            /// Future updates are tracked. Use `write_updates` to persist them to the
-            /// cache file. If the file already exists its contents are overwritten.
-            ///
-            /// Arguments:
-            ///     path (str): The path to the cache file
-            ///
-            /// Returns:
-            ///     None:
-            fn cache(&self, path: std::path::PathBuf) -> Result<(), GraphError> {
-                $crate::serialise::CacheOps::cache(&self.$field, path)
-            }
-
-            /// Persist the new updates by appending them to the cache file.
-            ///
-            /// Returns:
-            ///     None:
-            fn write_updates(&self) -> Result<(), GraphError> {
-                $crate::serialise::CacheOps::write_updates(&self.$field)
-            }
-
-            #[doc = concat!(" Load ", $name, " from a file and initialise it as a cache file.")]
-            ///
-            /// Future updates are tracked. Use `write_updates` to persist them to the
-            /// cache file.
-            ///
-            /// Arguments:
-            ///   path (str): The path to the cache file
-            ///
-            /// Returns:
-            #[doc = concat!("   ", $name,": the loaded graph with initialised cache")]
-            #[staticmethod]
-            fn load_cached(path: PathBuf) -> Result<$base_type, GraphError> {
-                <$base_type as $crate::serialise::CacheOps>::load_cached(path)
-            }
-
-            #[doc = concat!(" Load ", $name, " from a file.")]
+            #[doc = concat!(" Load ", $name, " from a parquet file.")]
             ///
             /// Arguments:
             ///   path (str): The path to the file.
@@ -55,10 +18,10 @@ macro_rules! impl_serialise {
             #[doc = concat!("   ", $name, ":")]
             #[staticmethod]
             fn load_from_file(path: PathBuf) -> Result<$base_type, GraphError> {
-                <$base_type as $crate::serialise::StableDecode>::decode(path)
+                <$base_type as $crate::serialise::StableDecode>::decode(&path)
             }
 
-            #[doc = concat!(" Saves the ", $name, " to the given path.")]
+            #[doc = concat!(" Saves the ", $name, " to the given path in parquet format.")]
             ///
             /// Arguments:
             ///     path (str): The path to the file.
@@ -89,16 +52,19 @@ macro_rules! impl_serialise {
             #[doc = concat!("   ", $name, ":")]
             #[staticmethod]
             fn deserialise(bytes: &[u8]) -> Result<$base_type, GraphError> {
-                <$base_type as $crate::serialise::InternalStableDecode>::decode_from_bytes(bytes)
+                <$base_type as $crate::serialise::StableDecode>::decode_from_bytes(bytes)
             }
 
             #[doc = concat!(" Serialise ", $name, " to bytes.")]
             ///
             /// Returns:
             ///   bytes:
-            fn serialise<'py>(&self, py: Python<'py>) -> Bound<'py, pyo3::types::PyBytes> {
-                let bytes = $crate::serialise::StableEncode::encode_to_vec(&self.$field);
-                pyo3::types::PyBytes::new(py, &bytes)
+            fn serialise<'py>(
+                &self,
+                py: Python<'py>,
+            ) -> Result<Bound<'py, pyo3::types::PyBytes>, GraphError> {
+                let bytes = $crate::serialise::StableEncode::encode_to_bytes(&self.$field)?;
+                Ok(pyo3::types::PyBytes::new(py, &bytes))
             }
         }
     };
diff --git a/raphtory/src/python/types/repr.rs b/raphtory/src/python/types/repr.rs
index 243cbb6a25..6dcca6535f 100644
--- a/raphtory/src/python/types/repr.rs
+++ b/raphtory/src/python/types/repr.rs
@@ -10,8 +10,11 @@ use bigdecimal::BigDecimal;
 use chrono::{DateTime, NaiveDateTime, TimeZone};
 use indexmap::IndexMap;
 use itertools::Itertools;
-use pyo3::{prelude::PyAnyMethods, Bound, PyAny, PyObject, Python};
-use raphtory_api::core::{entities::GID, storage::arc_str::ArcStr};
+use pyo3::{prelude::PyAnyMethods, Bound, Py, PyAny, Python};
+use raphtory_api::core::{
+    entities::{properties::prop::PropArray, GID},
+    storage::arc_str::ArcStr,
+};
 use std::{collections::HashMap, error::Error, ops::Deref, sync::Arc};
 
 pub fn iterator_repr<I: Iterator<Item = V>, V: Repr>(iter: I) -> String {
@@ -90,9 +93,9 @@ impl<T: Repr, const N: usize> Repr for [T; N] {
     }
 }
 
-impl Repr for PyObject {
+impl Repr for Py<PyAny> {
     fn repr(&self) -> String {
-        Python::with_gil(|py| Repr::repr(self.bind(py)))
+        Python::attach(|py| Repr::repr(self.bind(py)))
     }
 }
 
@@ -242,6 +245,13 @@ impl<T: Repr> Repr for Vec<T> {
     }
 }
 
+impl Repr for PropArray {
+    fn repr(&self) -> String {
+        let repr = self.iter().map(|v| v.repr()).join(", ");
+        format!("[{}]", repr)
+    }
+}
+
 impl<T: Repr> Repr for Arc<[T]> {
     fn repr(&self) -> String {
         self.deref().repr()
@@ -274,6 +284,24 @@ impl<S: Repr, T: Repr> Repr for (S, T) {
     }
 }
 
+// three element tuple
+impl<S: Repr, T: Repr, U: Repr> Repr for (S, T, U) {
+    fn repr(&self) -> String {
+        format!("({}, {}, {})", self.0.repr(), self.1.repr(), self.2.repr())
+    }
+}
+impl<S: Repr, T: Repr, U: Repr, V: Repr> Repr for (S, T, U, V) {
+    fn repr(&self) -> String {
+        format!(
+            "({}, {}, {}, {})",
+            self.0.repr(),
+            self.1.repr(),
+            self.2.repr(),
+            self.3.repr()
+        )
+    }
+}
+
 impl<'a, T: Repr> Repr for LockedView<'a, T> {
     fn repr(&self) -> String {
         self.deref().repr()
diff --git a/raphtory/src/python/types/result_iterable.rs b/raphtory/src/python/types/result_iterable.rs
index 61be0d74a7..279cfb9b3d 100644
--- a/raphtory/src/python/types/result_iterable.rs
+++ b/raphtory/src/python/types/result_iterable.rs
@@ -70,6 +70,10 @@ impl ResultUtcDateTimeIterable {
         self.repr()
     }
 
+    /// Materialise the iterable as a list of datetimes, raising if any element produced an error.
+    ///
+    /// Returns:
+    ///     list[datetime]: one datetime per element.
     fn collect(&self) -> PyResult<Vec<DateTime<Utc>>> {
         self.iter()
             .map(|result| result.map_err(PyErr::from))
@@ -158,6 +162,10 @@ impl NestedResultUtcDateTimeIterable {
         self.repr()
     }
 
+    /// Materialise the iterable as a nested list of datetimes, raising if any element produced an error.
+    ///
+    /// Returns:
+    ///     list[list[datetime]]: one inner list per outer element.
     fn collect(&self) -> PyResult<Vec<Vec<DateTime<Utc>>>> {
         self.iter()
             .map(|inner_iter| {
@@ -235,6 +243,10 @@ impl ResultOptionUtcDateTimeIterable {
         self.repr()
     }
 
+    /// Materialise the iterable as a list of optional datetimes, raising if any element produced an error.
+    ///
+    /// Returns:
+    ///     list[Optional[datetime]]: one entry per element (None where absent).
     fn collect(&self) -> PyResult<Vec<Option<DateTime<Utc>>>> {
         self.iter()
             .map(|result| result.map_err(PyErr::from))
@@ -326,6 +338,10 @@ impl NestedResultOptionUtcDateTimeIterable {
         self.repr()
     }
 
+    /// Materialise the iterable as a nested list of optional datetimes, raising if any element produced an error.
+    ///
+    /// Returns:
+    ///     list[list[Optional[datetime]]]: one inner list per outer element (entries are None where absent).
     fn collect(&self) -> PyResult<Vec<Vec<Option<DateTime<Utc>>>>> {
         self.iter()
             .map(|inner_iter| {
diff --git a/raphtory/src/python/types/result_vec_iterable.rs b/raphtory/src/python/types/result_vec_iterable.rs
index 654d2ab46e..0327a561f6 100644
--- a/raphtory/src/python/types/result_vec_iterable.rs
+++ b/raphtory/src/python/types/result_vec_iterable.rs
@@ -71,6 +71,10 @@ impl ResultVecUtcDateTimeIterable {
         self.repr()
     }
 
+    /// Materialise the iterable as a list of datetime lists, raising if any element produced an error.
+    ///
+    /// Returns:
+    ///     list[list[datetime]]: one datetime list per outer element.
     fn collect(&self) -> PyResult<Vec<Vec<DateTime<Utc>>>> {
         self.iter()
             .map(|result| result.map_err(PyErr::from))
@@ -162,6 +166,10 @@ impl NestedResultVecUtcDateTimeIterable {
         self.repr()
     }
 
+    /// Materialise the iterable as a deeply-nested list of datetime lists, raising if any element produced an error.
+    ///
+    /// Returns:
+    ///     list[list[list[datetime]]]: outer list per outer element; each contains a list of datetime lists.
     fn collect(&self) -> PyResult<Vec<Vec<Vec<DateTime<Utc>>>>> {
         self.iter()
             .map(|inner_iter| {
diff --git a/raphtory/src/python/types/wrappers/document.rs b/raphtory/src/python/types/wrappers/document.rs
index d12a5de799..c4405c19fd 100644
--- a/raphtory/src/python/types/wrappers/document.rs
+++ b/raphtory/src/python/types/wrappers/document.rs
@@ -35,7 +35,7 @@ impl PyDocument {
     /// Returns:
     ///     Optional[Any]:
     #[getter]
-    fn entity(&self, py: Python) -> PyResult<PyObject> {
+    fn entity(&self, py: Python) -> PyResult<Py<PyAny>> {
         match &self.0.entity {
             DocumentEntity::Node(entity) => entity.clone().into_py_any(py),
             DocumentEntity::Edge(entity) => entity.clone().into_py_any(py),
@@ -68,6 +68,10 @@ impl PyEmbedding {
         self.repr()
     }
 
+    /// Returns the embedding as a `pyarrow.Array` of floats.
+    ///
+    /// Returns:
+    ///     pyarrow.Array:
     fn to_arrow(&self) -> PyArray {
         PyArray::from_array_ref(Arc::new(self.0.inner().clone()))
     }
diff --git a/raphtory/src/python/types/wrappers/iterators.rs b/raphtory/src/python/types/wrappers/iterators.rs
index 59396a4b67..221ff68255 100644
--- a/raphtory/src/python/types/wrappers/iterators.rs
+++ b/raphtory/src/python/types/wrappers/iterators.rs
@@ -1,7 +1,7 @@
 use crate::db::api::view::{BoxedLIter, IntoDynBoxed};
 use ouroboros::self_referencing;
 use pyo3::{
-    pyclass, pymethods, BoundObject, IntoPyObject, PyErr, PyObject, PyRef, PyResult, Python,
+    pyclass, pymethods, BoundObject, IntoPyObject, Py, PyAny, PyErr, PyRef, PyResult, Python,
 };
 
 #[pyclass]
@@ -10,7 +10,7 @@ pub struct PyBorrowingIterator {
     inner: Box<dyn PyIter>,
     #[borrows(inner)]
     #[covariant]
-    iter: BoxedLIter<'this, PyResult<PyObject>>,
+    iter: BoxedLIter<'this, PyResult<Py<PyAny>>>,
 }
 
 #[pymethods]
@@ -18,13 +18,13 @@ impl PyBorrowingIterator {
     fn __iter__(slf: PyRef<'_, Self>) -> PyRef<'_, Self> {
         slf
     }
-    fn __next__(&mut self) -> Option<PyResult<PyObject>> {
+    fn __next__(&mut self) -> Option<PyResult<Py<PyAny>>> {
         self.with_iter_mut(|iter| iter.next())
     }
 }
 
 pub trait PyIter: Send + Sync + 'static {
-    fn iter(&self) -> BoxedLIter<'_, PyResult<PyObject>>;
+    fn iter(&self) -> BoxedLIter<'_, PyResult<Py<PyAny>>>;
 
     fn into_py_iter(self) -> PyBorrowingIterator
     where
@@ -39,16 +39,16 @@ pub trait PyIter: Send + Sync + 'static {
 }
 
 pub trait IntoPyIter<'a> {
-    fn into_py_iter(self) -> BoxedLIter<'a, PyResult<PyObject>>;
+    fn into_py_iter(self) -> BoxedLIter<'a, PyResult<Py<PyAny>>>;
 }
 
 impl<'a, I: Iterator + Send + Sync + 'a> IntoPyIter<'a> for I
 where
     I::Item: for<'py> IntoPyObject<'py>,
 {
-    fn into_py_iter(self) -> BoxedLIter<'a, PyResult<PyObject>> {
+    fn into_py_iter(self) -> BoxedLIter<'a, PyResult<Py<PyAny>>> {
         self.map(|v| {
-            Python::with_gil(|py| {
+            Python::attach(|py| {
                 Ok(v.into_pyobject(py)
                     .map_err(|e| e.into())?
                     .into_any()
@@ -60,7 +60,7 @@ where
 }
 
 pub trait IntoPyIterResult<'a> {
-    fn into_py_iter_result(self) -> BoxedLIter<'a, PyResult<PyObject>>;
+    fn into_py_iter_result(self) -> BoxedLIter<'a, PyResult<Py<PyAny>>>;
 }
 
 impl<'a, T, E, I: Iterator<Item = Result<T, E>> + Send + Sync + 'a> IntoPyIterResult<'a> for I
@@ -68,9 +68,9 @@ where
     T: for<'py> IntoPyObject<'py>,
     E: Into<PyErr>,
 {
-    fn into_py_iter_result(self) -> BoxedLIter<'a, PyResult<PyObject>> {
+    fn into_py_iter_result(self) -> BoxedLIter<'a, PyResult<Py<PyAny>>> {
         self.map(|item| {
-            Python::with_gil(|py| match item {
+            Python::attach(|py| match item {
                 Ok(value) => Ok(value
                     .into_pyobject(py)
                     .map_err(|e| e.into())?
@@ -84,7 +84,7 @@ where
 }
 
 pub trait IntoPyIterTupleResult<'a> {
-    fn into_py_iter_tuple_result(self) -> BoxedLIter<'a, PyResult<PyObject>>;
+    fn into_py_iter_tuple_result(self) -> BoxedLIter<'a, PyResult<Py<PyAny>>>;
 }
 
 impl<'a, X, T, E, I: Iterator<Item = (X, Result<T, E>)> + Send + Sync + 'a>
@@ -94,9 +94,9 @@ where
     T: for<'py> IntoPyObject<'py>,
     E: Into<PyErr>,
 {
-    fn into_py_iter_tuple_result(self) -> BoxedLIter<'a, PyResult<PyObject>> {
+    fn into_py_iter_tuple_result(self) -> BoxedLIter<'a, PyResult<Py<PyAny>>> {
         self.map(|(tuple_left, result)| {
-            Python::with_gil(|py| match result {
+            Python::attach(|py| match result {
                 Ok(value) => Ok((tuple_left, value).into_pyobject(py)?.into_any().unbind()),
                 Err(err) => Err(err.into()),
             })
diff --git a/raphtory/src/python/types/wrappers/prop.rs b/raphtory/src/python/types/wrappers/prop.rs
index 57f914196e..67b5dab070 100644
--- a/raphtory/src/python/types/wrappers/prop.rs
+++ b/raphtory/src/python/types/wrappers/prop.rs
@@ -22,7 +22,6 @@ impl Repr for Prop {
             Prop::F64(v) => v.repr(),
             Prop::DTime(v) => v.repr(),
             Prop::NDTime(v) => v.repr(),
-            Prop::Array(v) => format!("{:?}", v),
             Prop::I32(v) => v.repr(),
             Prop::U32(v) => v.repr(),
             Prop::F32(v) => v.repr(),
diff --git a/raphtory/src/python/utils/export.rs b/raphtory/src/python/utils/export.rs
index 530b0af0c6..dc8c864216 100644
--- a/raphtory/src/python/utils/export.rs
+++ b/raphtory/src/python/utils/export.rs
@@ -8,10 +8,7 @@ use raphtory_api::core::{
     storage::{arc_str::ArcStr, timeindex::AsTime},
 };
 use rayon::{iter::IntoParallelRefIterator, prelude::*};
-use std::{
-    collections::{HashMap, HashSet},
-    sync::Arc,
-};
+use std::collections::{HashMap, HashSet};
 
 pub(crate) fn extract_properties<P>(
     include_property_history: bool,
@@ -84,7 +81,7 @@ pub(crate) fn extract_properties<P>(
                 let mut prop_vec = vec![];
                 prop_view.iter().for_each(|(time, prop)| {
                     let prop_time = Prop::DTime(time.dt().unwrap());
-                    prop_vec.push(Prop::List(Arc::from(vec![prop_time, prop])))
+                    prop_vec.push(Prop::List(vec![prop_time, prop].into()))
                 });
                 let wrapped = Prop::from(prop_vec);
                 let _ = properties_map.insert(column_name, wrapped);
@@ -93,7 +90,7 @@ pub(crate) fn extract_properties<P>(
                     .iter()
                     .map(|(k, v)| Prop::from(vec![Prop::from(k.t()), v]))
                     .collect_vec();
-                let wrapped = Prop::List(Arc::from(vec_props));
+                let wrapped = Prop::List(vec_props.into());
                 let _ = properties_map.insert(column_name, wrapped);
             }
         });
@@ -116,16 +113,11 @@ pub(crate) fn get_column_names_from_props(
     let mut is_prop_both_temp_and_const: HashSet<String> = HashSet::new();
     let temporal_properties: HashSet<ArcStr> = edge_meta
         .temporal_prop_mapper()
-        .get_keys()
-        .iter()
-        .cloned()
-        .collect();
-    let metadata: HashSet<ArcStr> = edge_meta
-        .metadata_mapper()
-        .get_keys()
+        .keys()
         .iter()
         .cloned()
         .collect();
+    let metadata: HashSet<ArcStr> = edge_meta.metadata_mapper().keys().iter().cloned().collect();
     metadata
         .intersection(&temporal_properties)
         .for_each(|name| {
diff --git a/raphtory/src/python/utils/mod.rs b/raphtory/src/python/utils/mod.rs
index 9a9534166c..27b675b2c6 100644
--- a/raphtory/src/python/utils/mod.rs
+++ b/raphtory/src/python/utils/mod.rs
@@ -15,7 +15,7 @@ use crate::{
 };
 use chrono::{DateTime, Utc};
 use numpy::{IntoPyArray, PyArray};
-use pyo3::{exceptions::PyTypeError, prelude::*, pybacked::PyBackedStr, BoundObject};
+use pyo3::{exceptions::PyTypeError, prelude::*, pybacked::PyBackedStr, Borrowed, BoundObject};
 use raphtory_api::core::entities::{
     properties::prop::{Prop, PropUnwrap},
     VID,
@@ -34,8 +34,9 @@ pub enum PyNodeRef {
     Internal(VID),
 }
 
-impl<'source> FromPyObject<'source> for PyNodeRef {
-    fn extract_bound(ob: &Bound<'source, PyAny>) -> PyResult<Self> {
+impl<'py> FromPyObject<'_, 'py> for PyNodeRef {
+    type Error = PyErr;
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
         if let Ok(s) = ob.extract::<PyBackedStr>() {
             Ok(PyNodeRef::ExternalStr(s))
         } else if let Ok(gid) = ob.extract::<u64>() {
@@ -177,7 +178,7 @@ impl PyWindowSet {
 
 #[pyclass(name = "Iterable")]
 pub struct PyGenericIterable {
-    build_iter: Box<dyn Fn() -> BoxedIter<PyResult<PyObject>> + Send + Sync>,
+    build_iter: Box<dyn Fn() -> BoxedIter<PyResult<Py<PyAny>>> + Send + Sync>,
 }
 
 impl<F, I: Send + Sync, T> From<F> for PyGenericIterable
@@ -187,10 +188,10 @@ where
     T: for<'py> IntoPyObject<'py> + 'static,
 {
     fn from(value: F) -> Self {
-        let build_py_iter: Box<dyn Fn() -> BoxedIter<PyResult<PyObject>> + Send + Sync> =
+        let build_py_iter: Box<dyn Fn() -> BoxedIter<PyResult<Py<PyAny>>> + Send + Sync> =
             Box::new(move || {
                 Box::new(value().map(|item| {
-                    Python::with_gil(|py| {
+                    Python::attach(|py| {
                         Ok(item
                             .into_pyobject(py)
                             .map_err(|e| e.into())?
@@ -214,11 +215,11 @@ impl PyGenericIterable {
 
 #[pyclass(name = "Iterator", unsendable)]
 pub struct PyGenericIterator {
-    iter: Box<dyn Iterator<Item = PyResult<PyObject>>>,
+    iter: Box<dyn Iterator<Item = PyResult<Py<PyAny>>>>,
 }
 
 impl PyGenericIterator {
-    pub fn new(iter: Box<dyn Iterator<Item = PyResult<PyObject>>>) -> Self {
+    pub fn new(iter: Box<dyn Iterator<Item = PyResult<Py<PyAny>>>>) -> Self {
         Self { iter }
     }
     pub fn from_result_iter<I, T, E>(iter: I) -> Self
@@ -228,7 +229,7 @@ impl PyGenericIterator {
         PyErr: From<E>,
     {
         let py_iter = Box::new(iter.map(|result| {
-            Python::with_gil(|py| match result {
+            Python::attach(|py| match result {
                 Ok(item) => Ok(item
                     .into_pyobject(py)
                     .map_err(|e| e.into())?
@@ -248,7 +249,7 @@ where
 {
     fn from(value: I) -> Self {
         let py_iter = Box::new(value.map(|item| {
-            Python::with_gil(|py| {
+            Python::attach(|py| {
                 Ok(item
                     .into_pyobject(py)
                     .map_err(|e| e.into())?
@@ -261,7 +262,7 @@ where
 }
 
 impl IntoIterator for PyGenericIterator {
-    type Item = PyResult<PyObject>;
+    type Item = PyResult<Py<PyAny>>;
 
     type IntoIter = Box<dyn Iterator<Item = Self::Item>>;
 
@@ -275,7 +276,7 @@ impl PyGenericIterator {
     fn __iter__(slf: PyRef<'_, Self>) -> PyRef<'_, Self> {
         slf
     }
-    fn __next__(&mut self) -> Option<PyResult<PyObject>> {
+    fn __next__(&mut self) -> Option<PyResult<Py<PyAny>>> {
         self.iter.next()
     }
 }
@@ -412,13 +413,13 @@ impl<'py> IntoPyObject<'py> for NumpyArray {
 // This function takes a function that returns a future instead of taking just a future because
 // a task might return an unsendable future but what we can do is making a function returning that
 // future which is sendable itself
-pub(crate) fn execute_async_task<T, F, O>(task: T) -> O
+pub fn execute_async_task<T, F, O>(task: T) -> O
 where
     T: FnOnce() -> F + Send + 'static,
     F: Future<Output = O> + 'static,
     O: Send + 'static,
 {
-    Python::with_gil(|py| py.allow_threads(move || get_runtime().block_on(task())))
+    Python::attach(|py| py.detach(move || get_runtime().block_on(task())))
 }
 
 static RUNTIME: OnceLock<Runtime> = OnceLock::new();
diff --git a/raphtory/src/search/edge_index.rs b/raphtory/src/search/edge_index.rs
index 4db50a1fa4..48a5b47bee 100644
--- a/raphtory/src/search/edge_index.rs
+++ b/raphtory/src/search/edge_index.rs
@@ -10,12 +10,15 @@ use crate::{
     },
 };
 use ahash::HashSet;
-use raphtory_api::core::storage::dict_mapper::MaybeNew;
+use raphtory_api::core::{
+    entities::{LayerId, LayerIds},
+    storage::dict_mapper::MaybeNew,
+};
 use raphtory_storage::{
     core_ops::CoreGraphOps,
     graph::{edges::edge_storage_ops::EdgeStorageOps, graph::GraphStorage},
 };
-use rayon::{iter::IntoParallelIterator, prelude::ParallelIterator};
+use rayon::prelude::ParallelIterator;
 use std::{
     fmt::{Debug, Formatter},
     path::PathBuf,
@@ -209,10 +212,10 @@ impl EdgeIndex {
 
     pub(crate) fn index_edges_fields(&self, graph: &GraphStorage) -> Result<(), GraphError> {
         let mut writer = self.entity_index.index.writer(100_000_000)?;
-        (0..graph.count_edges())
-            .into_par_iter()
-            .try_for_each(|e_id| {
-                let edge = graph.core_edge(EID(e_id));
+        graph
+            .edges()
+            .par_iter(&LayerIds::All)
+            .try_for_each(|edge| {
                 let e_view = EdgeView::new(graph, edge.out_ref());
                 self.index_edge(e_view, &writer)?;
                 Ok::<(), GraphError>(())
@@ -239,7 +242,7 @@ impl EdgeIndex {
         graph: &GraphStorage,
         edge_id: MaybeNew<EID>,
         t: EventTime,
-        layer_id: usize,
+        layer_id: LayerId,
         props: &[(usize, Prop)],
     ) -> Result<(), GraphError> {
         let eid_u64 = edge_id.inner().as_u64();
@@ -279,7 +282,7 @@ impl EdgeIndex {
     pub(crate) fn add_edge_metadata(
         &self,
         edge_id: EID,
-        layer_id: usize,
+        layer_id: LayerId,
         props: &[(usize, Prop)],
     ) -> Result<(), GraphError> {
         let indexes = self.entity_index.metadata_indexes.read_recursive();
@@ -298,7 +301,7 @@ impl EdgeIndex {
     pub(crate) fn update_edge_metadata(
         &self,
         edge_id: EID,
-        layer_id: usize,
+        layer_id: LayerId,
         props: &[(usize, Prop)],
     ) -> Result<(), GraphError> {
         let indexes = self.entity_index.metadata_indexes.read_recursive();
diff --git a/raphtory/src/search/entity_index.rs b/raphtory/src/search/entity_index.rs
index 072d06006e..a8780cd1b1 100644
--- a/raphtory/src/search/entity_index.rs
+++ b/raphtory/src/search/entity_index.rs
@@ -9,7 +9,7 @@ use crate::{
 use parking_lot::RwLock;
 use raphtory_api::core::entities::{
     properties::{meta::Meta, prop::PropType, tprop::TPropOps},
-    LayerIds, EID, VID,
+    LayerId, LayerIds, EID, VID,
 };
 use raphtory_storage::{
     core_ops::CoreGraphOps,
@@ -126,7 +126,7 @@ impl EntityIndex {
                     .into_par_iter()
                     .try_for_each(|v_id| {
                         let node = graph.core_node(VID(v_id));
-                        if let Some(prop_value) = node.prop(prop_id) {
+                        if let Some(prop_value) = node.constant_prop_layer(LayerId(0), prop_id) {
                             let prop_doc = prop_index
                                 .create_node_metadata_document(v_id as u64, &prop_value)?;
                             writer.add_document(prop_doc)?;
diff --git a/raphtory/src/search/exploded_edge_filter_executor.rs b/raphtory/src/search/exploded_edge_filter_executor.rs
index ba41cf33fd..a19368d00a 100644
--- a/raphtory/src/search/exploded_edge_filter_executor.rs
+++ b/raphtory/src/search/exploded_edge_filter_executor.rs
@@ -27,7 +27,7 @@ use crate::{
 };
 use itertools::Itertools;
 use raphtory_api::core::{
-    entities::EID,
+    entities::{LayerId, EID},
     storage::timeindex::{AsTime, EventTime},
 };
 use raphtory_storage::graph::edges::edge_storage_ops::EdgeStorageOps;
@@ -341,8 +341,12 @@ impl<'a> ExplodedEdgeFilterExecutor<'a> {
         let edges = exploded_edge_ids
             .into_iter()
             .filter_map(|(tie, eid, layer_id)| {
-                if filtered_graph.filter_exploded_edge(eid.with_layer(layer_id), tie) {
-                    let e_ref = graph.core_edge(eid).out_ref().at(tie).at_layer(layer_id);
+                if filtered_graph.filter_exploded_edge(eid.with_layer(LayerId(layer_id)), tie) {
+                    let e_ref = graph
+                        .core_edge(eid)
+                        .out_ref()
+                        .at(tie)
+                        .at_layer(LayerId(layer_id));
                     Some(EdgeView::new(graph.clone(), e_ref))
                 } else {
                     None
diff --git a/raphtory/src/search/graph_index.rs b/raphtory/src/search/graph_index.rs
index 8db90830b1..630886490b 100644
--- a/raphtory/src/search/graph_index.rs
+++ b/raphtory/src/search/graph_index.rs
@@ -7,24 +7,24 @@ use crate::{
     errors::GraphError,
     prelude::*,
     search::{edge_index::EdgeIndex, node_index::NodeIndex, searcher::Searcher},
-    serialise::GraphFolder,
+    serialise::{GraphFolder, GraphPaths, InnerGraphFolder},
 };
 use parking_lot::RwLock;
-use raphtory_api::core::storage::dict_mapper::MaybeNew;
+use raphtory_api::core::{entities::LayerId, storage::dict_mapper::MaybeNew};
 use raphtory_storage::graph::graph::GraphStorage;
 use std::{
     ffi::OsStr,
     fmt::Debug,
     fs,
     fs::File,
+    io::{Seek, Write},
     ops::Deref,
     path::{Path, PathBuf},
     sync::Arc,
 };
 use tempfile::TempDir;
-use uuid::Uuid;
 use walkdir::WalkDir;
-use zip::{write::FileOptions, ZipArchive, ZipWriter};
+use zip::{write::SimpleFileOptions, ZipArchive, ZipWriter};
 
 #[derive(Clone)]
 pub struct Index {
@@ -43,7 +43,7 @@ impl Index {
 #[derive(Clone)]
 pub struct ImmutableGraphIndex {
     pub(crate) index: Index,
-    pub(crate) path: Arc<GraphFolder>,
+    pub(crate) path: Arc<InnerGraphFolder>,
     pub index_spec: Arc<IndexSpec>,
 }
 
@@ -77,14 +77,22 @@ impl MutableGraphIndex {
         Ok(())
     }
 
+    pub(crate) fn add_new_node(
+        &self,
+        node_id: VID,
+        name: String,
+        node_type: Option<&str>,
+    ) -> Result<(), GraphError> {
+        self.index.node_index.add_new_node(node_id, name, node_type)
+    }
+
     pub(crate) fn add_node_update(
         &self,
-        graph: &GraphStorage,
         t: EventTime,
-        v: MaybeNew<VID>,
+        v: VID,
         props: &[(usize, Prop)],
     ) -> Result<(), GraphError> {
-        self.index.node_index.add_node_update(graph, t, v, props)?;
+        self.index.node_index.add_node_update(t, v, props)?;
         Ok(())
     }
 
@@ -110,7 +118,7 @@ impl MutableGraphIndex {
         graph: &GraphStorage,
         edge_id: MaybeNew<EID>,
         t: EventTime,
-        layer: usize,
+        layer: LayerId,
         props: &[(usize, Prop)],
     ) -> Result<(), GraphError> {
         self.index
@@ -121,7 +129,7 @@ impl MutableGraphIndex {
     pub(crate) fn add_edge_metadata(
         &self,
         edge_id: EID,
-        layer: usize,
+        layer: LayerId,
         props: &[(usize, Prop)],
     ) -> Result<(), GraphError> {
         self.index
@@ -132,7 +140,7 @@ impl MutableGraphIndex {
     pub(crate) fn update_edge_metadata(
         &self,
         edge_id: EID,
-        layer: usize,
+        layer: LayerId,
         props: &[(usize, Prop)],
     ) -> Result<(), GraphError> {
         self.index
@@ -181,7 +189,7 @@ impl GraphIndex {
             let temp_dir = match cached_graph_path {
                 // Creates index in a temp dir within cache graph dir.
                 // The intention is to avoid creating index in a tmp dir that could be on another file system.
-                Some(path) => TempDir::new_in(path.get_base_path())?,
+                Some(path) => TempDir::new_in(path.root())?,
                 None => TempDir::new()?,
             };
 
@@ -213,7 +221,7 @@ impl GraphIndex {
     pub fn load_from_path(path: &GraphFolder) -> Result<GraphIndex, GraphError> {
         if path.is_zip() {
             let index_path = TempDir::new()?;
-            unzip_index(&path.get_base_path(), index_path.path())?;
+            unzip_index(&path.root(), index_path.path())?;
 
             let (index, index_spec) = load_indexes(index_path.path())?;
 
@@ -223,93 +231,55 @@ impl GraphIndex {
                 index_spec: Arc::new(RwLock::new(index_spec)),
             }))
         } else {
-            let index_path = path.get_index_path();
+            let index_path = path.index_path()?;
             let (index, index_spec) = load_indexes(index_path.as_path())?;
 
             Ok(GraphIndex::Immutable(ImmutableGraphIndex {
                 index,
-                path: Arc::new(path.clone()),
+                path: Arc::new(path.data_path()?),
                 index_spec: Arc::new(index_spec),
             }))
         }
     }
 
-    pub(crate) fn persist_to_disk(&self, path: &GraphFolder) -> Result<(), GraphError> {
+    pub(crate) fn persist_to_disk(&self, path: &impl GraphPaths) -> Result<(), GraphError> {
         let source_path = self.path().ok_or(GraphError::CannotPersistRamIndex)?;
-        let path = path.get_index_path();
-        let path = path.as_path();
-
-        let temp_path = &path.with_extension(format!("tmp-{}", Uuid::new_v4()));
-
-        copy_dir_recursive(&source_path, temp_path)?;
-
-        // Always overwrite the existing graph index when persisting, since the in-memory
-        // working index may have newer updates. The persisted index is decoupled from the
-        // active one, and changes remain in memory unless explicitly saved.
-        // This behavior mirrors how the in-memory graph works — updates are not persisted
-        // unless manually saved, except when using the cached view (see db/graph/views/cached_view).
-        // This however is reached only when write_updates, otherwise graph is not allowed to be written to
-        // the existing location anyway. See GraphError::NonEmptyGraphFolder.
-        if path.exists() {
-            fs::remove_dir_all(path)
-                .map_err(|_e| GraphError::FailedToRemoveExistingGraphIndex(path.to_path_buf()))?;
+        let path = path.index_path()?;
+        if source_path != path {
+            copy_dir_recursive(&source_path, &path)?;
         }
-
-        fs::rename(temp_path, path).map_err(|e| {
-            GraphError::IOErrorMsg(format!("Failed to rename temp index folder: {}", e))
-        })?;
-
         Ok(())
     }
 
-    pub(crate) fn persist_to_disk_zip(&self, path: &GraphFolder) -> Result<(), GraphError> {
-        let file = File::options()
-            .read(true)
-            .write(true)
-            .open(path.get_base_path())?;
-        let mut zip = ZipWriter::new_append(file)?;
-
+    pub(crate) fn persist_to_disk_zip<W: Write + Seek>(
+        &self,
+        writer: &mut ZipWriter<W>,
+        prefix: &str,
+    ) -> Result<(), GraphError> {
         let source_path = self.path().ok_or(GraphError::CannotPersistRamIndex)?;
-
         for entry in WalkDir::new(&source_path)
             .into_iter()
             .filter_map(Result::ok)
             .filter(|e| e.path().is_file())
         {
-            let rel_path = entry
-                .path()
-                .strip_prefix(&source_path)
-                .map_err(|e| GraphError::IOErrorMsg(format!("Failed to strip path: {}", e)))?;
-
-            let zip_entry_name = PathBuf::from("index")
-                .join(rel_path)
-                .to_string_lossy()
-                .into_owned();
-            zip.start_file::<_, ()>(zip_entry_name, FileOptions::default())
-                .map_err(|e| {
-                    GraphError::IOErrorMsg(format!("Failed to start zip file entry: {}", e))
-                })?;
+            let rel_path = entry.path().strip_prefix(&source_path)?;
 
-            let mut f = File::open(entry.path())
-                .map_err(|e| GraphError::IOErrorMsg(format!("Failed to open index file: {}", e)))?;
+            let zip_entry_name = Path::new(prefix).join(rel_path);
+            writer.start_file_from_path(zip_entry_name, SimpleFileOptions::default())?;
 
-            std::io::copy(&mut f, &mut zip).map_err(|e| {
-                GraphError::IOErrorMsg(format!("Failed to write zip content: {}", e))
-            })?;
-        }
-
-        zip.finish()
-            .map_err(|e| GraphError::IOErrorMsg(format!("Failed to finalize zip: {}", e)))?;
+            let mut f = File::open(entry.path())?;
 
+            std::io::copy(&mut f, writer)?;
+        }
         Ok(())
     }
 
     pub fn make_mutable_if_needed(&mut self) -> Result<(), GraphError> {
         if let GraphIndex::Immutable(immutable) = self {
-            let temp_dir = TempDir::new_in(&immutable.path.get_base_path())?;
+            let temp_dir = TempDir::new_in(immutable.path.as_ref())?;
             let temp_path = temp_dir.path();
 
-            copy_dir_recursive(&immutable.path.get_index_path(), temp_path)?;
+            copy_dir_recursive(&immutable.path.index_path(), temp_path)?;
 
             let node_index = NodeIndex::load_from_path(&temp_path.join("nodes"))?;
             let edge_index = EdgeIndex::load_from_path(&temp_path.join("edges"))?;
@@ -342,7 +312,7 @@ impl GraphIndex {
 
     pub fn path(&self) -> Option<PathBuf> {
         match self {
-            GraphIndex::Immutable(i) => Some(i.path.get_index_path()),
+            GraphIndex::Immutable(i) => Some(i.path.index_path()),
             GraphIndex::Mutable(m) => m.path.as_ref().map(|p| p.path().to_path_buf()),
             GraphIndex::Empty => None,
         }
@@ -494,16 +464,16 @@ mod graph_index_test {
 
     fn init_nodes_graph(graph: Graph) -> Graph {
         graph
-            .add_node(1, 1, [("p1", 1), ("p2", 2)], Some("fire_nation"))
+            .add_node(1, 1, [("p1", 1), ("p2", 2)], Some("fire_nation"), None)
             .unwrap();
         graph
-            .add_node(2, 1, [("p6", 6)], Some("fire_nation"))
+            .add_node(2, 1, [("p6", 6)], Some("fire_nation"), None)
             .unwrap();
         graph
-            .add_node(2, 2, [("p4", 5)], Some("fire_nation"))
+            .add_node(2, 2, [("p4", 5)], Some("fire_nation"), None)
             .unwrap();
         graph
-            .add_node(3, 3, [("p2", 4), ("p3", 3)], Some("water_tribe"))
+            .add_node(3, 3, [("p2", 4), ("p3", 3)], Some("water_tribe"), None)
             .unwrap();
         graph
     }
diff --git a/raphtory/src/search/mod.rs b/raphtory/src/search/mod.rs
index a986e13999..5611df1392 100644
--- a/raphtory/src/search/mod.rs
+++ b/raphtory/src/search/mod.rs
@@ -185,7 +185,7 @@ mod test_index {
     mod test_index_io {
         use crate::{
             db::{
-                api::view::{internal::InternalStorageOps, ResolvedIndexSpec, StaticGraphViewOps},
+                api::view::{internal::InternalStorageOps, ResolvedIndexSpec},
                 graph::views::filter::model::{
                     node_filter::{ops::NodeFilterOps, NodeFilter},
                     TryAsCompositeFilter,
@@ -201,16 +201,20 @@ mod test_index {
         };
         use tempfile::TempDir;
 
-        fn init_graph<G>(graph: G) -> G
-        where
-            G: StaticGraphViewOps + AdditionOps + PropertyAdditionOps,
-        {
+        fn temp_storage_path() -> std::path::PathBuf {
+            tempfile::tempdir().unwrap().path().to_path_buf()
+        }
+
+        fn init_graph() -> Graph {
+            let graph = Graph::new();
+
             graph
                 .add_node(
                     1,
                     "Alice",
                     vec![("p1", Prop::U64(1000u64))],
                     Some("fire_nation"),
+                    None,
                 )
                 .unwrap();
             graph
@@ -233,7 +237,7 @@ mod test_index {
         #[test]
         fn test_create_no_index_persist_no_index_on_encode_load_no_index_on_decode() {
             // No index persisted since it was never created
-            let graph = init_graph(Graph::new());
+            let graph = init_graph();
 
             let filter = NodeFilter::name().eq("Alice");
             assert_search_results(&graph, &filter, vec!["Alice"]);
@@ -249,7 +253,7 @@ mod test_index {
 
         #[test]
         fn test_create_index_persist_index_on_encode_load_index_on_decode() {
-            let graph = init_graph(Graph::new());
+            let graph = init_graph();
 
             // Created index
             graph.create_index().unwrap();
@@ -271,8 +275,8 @@ mod test_index {
         }
 
         #[test]
-        fn test_encoding_graph_twice_to_same_graph_path_fails() {
-            let graph = init_graph(Graph::new());
+        fn test_encoding_graph_twice_to_same_storage_path_fails() {
+            let graph = init_graph();
             graph.create_index().unwrap();
             let binding = TempDir::new().unwrap();
             let path = binding.path();
@@ -280,39 +284,17 @@ mod test_index {
             let result = graph.encode(path);
 
             match result {
-                Err(GraphError::IOError { source }) => {
-                    assert!(
-                        format!("{source}").contains("Cannot write graph into non empty folder"),
-                    );
+                Err(GraphError::NonEmptyGraphFolder(err_path)) => {
+                    assert_eq!(path, err_path);
                 }
                 Ok(_) => panic!("Expected error on second encode, got Ok"),
                 Err(e) => panic!("Unexpected error type: {:?}", e),
             }
         }
 
-        #[test]
-        fn test_write_updates_to_already_encoded_graph_succeeds() {
-            let graph = init_graph(Graph::new());
-            graph.create_index().unwrap();
-            let binding = TempDir::new().unwrap();
-            let path = binding.path();
-
-            graph.cache(path).unwrap();
-
-            graph
-                .add_node(1, "Ozai", [("prop", 1)], Some("fire_nation"))
-                .unwrap();
-
-            // This also tests if already existing index is replaced by new index
-            graph.write_updates().unwrap();
-
-            let graph = Graph::decode(path).unwrap();
-            assert_search_results(&graph, &NodeFilter::name().eq("Ozai"), vec!["Ozai"]);
-        }
-
         #[test]
         fn test_create_index_persist_index_on_encode_update_index_load_persisted_index_on_decode() {
-            let graph = init_graph(Graph::new());
+            let graph = init_graph();
 
             // Created index
             graph.create_index().unwrap();
@@ -332,6 +314,7 @@ mod test_index {
                     "Tommy",
                     vec![("p1", Prop::U64(5u64))],
                     Some("water_tribe"),
+                    None,
                 )
                 .unwrap();
             let filter2 = NodeFilter::name().eq("Tommy");
@@ -352,6 +335,7 @@ mod test_index {
                     "Tommy",
                     vec![("p1", Prop::U64(5u64))],
                     Some("water_tribe"),
+                    None,
                 )
                 .unwrap();
             let filter2 = NodeFilter::name().eq("Tommy");
@@ -363,6 +347,7 @@ mod test_index {
             graph.encode(path).unwrap();
 
             // Should load the updated graph and index
+            let storage_path = path.parent().unwrap().to_path_buf();
             let graph = Graph::decode(path).unwrap();
             let is_indexed = graph.get_storage().unwrap().is_indexed();
             assert!(is_indexed);
@@ -372,14 +357,15 @@ mod test_index {
 
         #[test]
         fn test_zip_encode_decode_index() {
-            let graph = init_graph(Graph::new());
+            let graph = init_graph();
             graph.create_index().unwrap();
             let tmp_dir = TempDir::new().unwrap();
             let zip_path = tmp_dir.path().join("graph.zip");
             let folder = GraphFolder::new_as_zip(zip_path);
             graph.encode(&folder).unwrap();
 
-            let graph = Graph::decode(folder).unwrap();
+            let storage_path = tmp_dir.path().to_path_buf();
+            let graph = Graph::decode(&folder).unwrap();
             let node = graph.node("Alice").unwrap();
             let node_type = node.node_type();
             assert_eq!(node_type, Some(ArcStr::from("fire_nation")));
@@ -389,19 +375,19 @@ mod test_index {
         }
 
         #[test]
-        fn test_encoding_graph_twice_to_same_graph_path_fails_zip() {
-            let graph = init_graph(Graph::new());
+        fn test_encoding_graph_twice_to_same_storage_path_fails_zip() {
+            let graph = init_graph();
             graph.create_index().unwrap();
             let tmp_dir = TempDir::new().unwrap();
             let zip_path = tmp_dir.path().join("graph.zip");
             let folder = GraphFolder::new_as_zip(&zip_path);
             graph.encode(&folder).unwrap();
             graph
-                .add_node(1, "Ozai", [("prop", 1)], Some("fire_nation"))
+                .add_node(1, "Ozai", [("prop", 1)], Some("fire_nation"), None)
                 .unwrap();
             let result = graph.encode(folder);
             match result {
-                Err(GraphError::IOError { source }) => {
+                Err(GraphError::IOError { source, .. }) => {
                     assert!(
                         format!("{source}").to_lowercase().contains("file exists"),
                         "{}",
@@ -415,7 +401,7 @@ mod test_index {
 
         #[test]
         fn test_immutable_graph_index_persistence() {
-            let graph = init_graph(Graph::new());
+            let graph = init_graph();
             graph.create_index().unwrap();
 
             let binding = TempDir::new().unwrap();
@@ -437,7 +423,7 @@ mod test_index {
 
         #[test]
         fn test_mutable_graph_index_persistence() {
-            let graph = init_graph(Graph::new());
+            let graph = init_graph();
             graph.create_index().unwrap();
 
             let binding = TempDir::new().unwrap();
@@ -449,7 +435,7 @@ mod test_index {
 
             // This converts immutable index to mutable index
             graph
-                .add_node(1, "Ozai", [("prop", 1)], Some("fire_nation"))
+                .add_node(1, "Ozai", [("prop", 1)], Some("fire_nation"), None)
                 .unwrap();
 
             // This tests that we are able to persist the mutable index
@@ -464,14 +450,14 @@ mod test_index {
 
         #[test]
         fn test_loading_zip_index_creates_mutable_index() {
-            let graph = init_graph(Graph::new());
+            let graph = init_graph();
             graph.create_index().unwrap();
             let tmp_dir = TempDir::new().unwrap();
             let zip_path = tmp_dir.path().join("graph.zip");
             let folder = GraphFolder::new_as_zip(&zip_path);
             graph.encode(&folder).unwrap();
 
-            let graph = Graph::decode(folder).unwrap();
+            let graph = Graph::decode(&folder).unwrap();
             let immutable = graph
                 .get_storage()
                 .unwrap()
@@ -483,7 +469,7 @@ mod test_index {
 
         #[test]
         fn test_loading_index_creates_immutable_index() {
-            let graph = init_graph(Graph::new());
+            let graph = init_graph();
             graph.create_index().unwrap();
             let binding = TempDir::new().unwrap();
             let path = binding.path();
@@ -503,7 +489,7 @@ mod test_index {
         fn test_create_index_in_ram() {
             global_info_logger();
 
-            let graph = init_graph(Graph::new());
+            let graph = init_graph();
             graph.create_index_in_ram().unwrap();
 
             let filter = NodeFilter::name().eq("Alice");
@@ -520,69 +506,15 @@ mod test_index {
             assert_search_results(&graph, &filter, vec!["Alice"]);
         }
 
-        #[test]
-        fn test_cached_graph_view() {
-            global_info_logger();
-            let graph = init_graph(Graph::new());
-            graph.create_index().unwrap();
-
-            let binding = TempDir::new().unwrap();
-            let path = binding.path();
-            graph.cache(path).unwrap();
-
-            graph
-                .add_node(
-                    2,
-                    "Tommy",
-                    vec![("p1", Prop::U64(5u64))],
-                    Some("water_tribe"),
-                )
-                .unwrap();
-            graph.write_updates().unwrap();
-
-            let graph = Graph::decode(path).unwrap();
-            let filter = NodeFilter::name().eq("Tommy");
-            assert_search_results(&graph, &filter, vec!["Tommy"]);
-        }
-
-        #[test]
-        fn test_cached_graph_view_create_index_after_graph_is_cached() {
-            global_info_logger();
-            let graph = init_graph(Graph::new());
-
-            let binding = TempDir::new().unwrap();
-            let path = binding.path();
-            graph.cache(path).unwrap();
-            // Creates index in a temp dir within graph dir
-            graph.create_index().unwrap();
-
-            graph
-                .add_node(
-                    2,
-                    "Tommy",
-                    vec![("p1", Prop::U64(5u64))],
-                    Some("water_tribe"),
-                )
-                .unwrap();
-            graph.write_updates().unwrap();
-
-            let graph = Graph::decode(path).unwrap();
-            let filter = NodeFilter::name().eq("Tommy");
-            assert_search_results(&graph, &filter, vec!["Tommy"]);
-        }
-
         #[test]
         #[ignore]
         fn test_too_many_open_files_graph_index() {
             use TempDir;
 
-            let tmp_dir = TempDir::new().unwrap();
-            let path = tmp_dir.path().to_path_buf();
-
             let mut graphs = vec![];
 
             for i in 0..1000 {
-                let graph = init_graph(Graph::new());
+                let graph = init_graph();
                 if let Err(e) = graph.create_index() {
                     match &e {
                         GraphError::IndexError { source } => {
@@ -593,14 +525,13 @@ mod test_index {
                         }
                     }
                 }
-                graph.cache(&path.join(format!("graph {i}"))).unwrap();
                 graphs.push(graph);
             }
         }
 
         #[test]
         fn test_graph_index_creation_with_too_many_properties() {
-            let graph = init_graph(Graph::new());
+            let graph = init_graph();
             let props: Vec<(String, Prop)> = (1..=100)
                 .map(|i| (format!("p{i}"), Prop::U64(i as u64)))
                 .collect();
@@ -622,7 +553,7 @@ mod test_index {
         // No new const prop index created because when index were created
         // these properties did not exist.
         fn test_graph_index_creation_for_incremental_node_update_no_new_prop_indexed() {
-            let graph = init_graph(Graph::new());
+            let graph = init_graph();
             graph.create_index().unwrap();
             let props: Vec<(String, Prop)> = (1..=100)
                 .map(|i| (format!("p{i}"), Prop::U64(i as u64)))
@@ -668,7 +599,13 @@ mod test_index {
         };
         use tempfile::{tempdir, TempDir};
 
-        fn init_graph(graph: Graph) -> Graph {
+        fn temp_storage_path() -> std::path::PathBuf {
+            tempfile::tempdir().unwrap().path().to_path_buf()
+        }
+
+        fn init_graph() -> Graph {
+            let graph = Graph::new();
+
             let nodes = vec![
                 (
                     1,
@@ -687,7 +624,7 @@ mod test_index {
             ];
 
             for (time, name, props, group, metadata) in nodes {
-                let node = graph.add_node(time, name, props, group).unwrap();
+                let node = graph.add_node(time, name, props, group, None).unwrap();
                 node.add_metadata(metadata).unwrap();
             }
 
@@ -719,8 +656,9 @@ mod test_index {
         }
 
         #[test]
+        #[ignore = "TODO: #2372"]
         fn test_with_all_props_index_spec() {
-            let graph = init_graph(Graph::new());
+            let graph = init_graph();
             let index_spec = IndexSpecBuilder::new(graph.clone())
                 .with_all_node_properties_and_metadata()
                 .with_all_edge_properties_and_metadata()
@@ -752,8 +690,9 @@ mod test_index {
         }
 
         #[test]
+        #[ignore = "TODO: #2372"]
         fn test_with_selected_props_index_spec() {
-            let graph = init_graph(Graph::new());
+            let graph = init_graph();
             let index_spec = IndexSpecBuilder::new(graph.clone())
                 .with_node_metadata(vec!["y"])
                 .unwrap()
@@ -791,7 +730,7 @@ mod test_index {
 
         #[test]
         fn test_with_invalid_property_returns_error() {
-            let graph = init_graph(Graph::new());
+            let graph = init_graph();
             let result = IndexSpecBuilder::new(graph.clone()).with_node_metadata(["xyz"]);
 
             assert!(matches!(result, Err(GraphError::PropertyMissingError(p)) if p == "xyz"));
@@ -799,7 +738,7 @@ mod test_index {
 
         #[test]
         fn test_build_empty_spec_by_default() {
-            let graph = init_graph(Graph::new());
+            let graph = init_graph();
             let index_spec = IndexSpecBuilder::new(graph.clone()).build();
 
             assert!(index_spec.node_metadata.is_empty());
@@ -825,8 +764,9 @@ mod test_index {
         }
 
         #[test]
+        #[ignore = "TODO: #2372"]
         fn test_mixed_node_and_edge_props_index_spec() {
-            let graph = init_graph(Graph::new());
+            let graph = init_graph();
 
             let index_spec = IndexSpecBuilder::new(graph.clone())
                 .with_node_metadata(vec!["x"])
@@ -863,7 +803,7 @@ mod test_index {
 
         #[test]
         fn test_get_index_spec_newly_created_index() {
-            let graph = init_graph(Graph::new());
+            let graph = init_graph();
 
             let index_spec = IndexSpecBuilder::new(graph.clone())
                 .with_node_metadata(vec!["x"])
@@ -880,8 +820,9 @@ mod test_index {
         }
 
         #[test]
+        #[ignore = "TODO: #2372"]
         fn test_get_index_spec_updated_index() {
-            let graph = init_graph(Graph::new());
+            let graph = init_graph();
 
             let index_spec = IndexSpecBuilder::new(graph.clone())
                 .with_edge_metadata(vec!["e_y"])
@@ -913,8 +854,9 @@ mod test_index {
         }
 
         #[test]
+        #[ignore = "TODO: #2372"]
         fn test_get_index_spec_updated_index_persisted_and_loaded() {
-            let graph = init_graph(Graph::new());
+            let graph = init_graph();
 
             let index_spec = IndexSpecBuilder::new(graph.clone())
                 .with_edge_metadata(vec!["e_y"])
@@ -924,8 +866,8 @@ mod test_index {
 
             let tmp_graph_dir = tempdir().unwrap();
             let path = tmp_graph_dir.path().to_path_buf();
-            graph.encode(path.clone()).unwrap();
-            let graph = Graph::decode(path.clone()).unwrap();
+            graph.encode(&path).unwrap();
+            let graph = Graph::decode(&path).unwrap();
 
             assert_eq!(index_spec, graph.get_index_spec().unwrap());
             let results = search_nodes(&graph, NodeFilter.metadata("y").eq(false));
@@ -945,7 +887,7 @@ mod test_index {
             let tmp_graph_dir = tempdir().unwrap();
             let path = tmp_graph_dir.path().to_path_buf();
             graph.encode(path.clone()).unwrap();
-            let graph = Graph::decode(path).unwrap();
+            let graph = Graph::decode(&path).unwrap();
 
             assert_eq!(index_spec, graph.get_index_spec().unwrap());
             let results = search_nodes(&graph, NodeFilter.metadata("y").eq(false));
@@ -956,7 +898,7 @@ mod test_index {
 
         #[test]
         fn test_get_index_spec_loaded_index() {
-            let graph = init_graph(Graph::new());
+            let graph = init_graph();
 
             let index_spec = IndexSpecBuilder::new(graph.clone())
                 .with_node_metadata(vec!["y"])
@@ -974,7 +916,7 @@ mod test_index {
             let path = tmp_graph_dir.path().to_path_buf();
             graph.encode(path.clone()).unwrap();
 
-            let graph = Graph::decode(path).unwrap();
+            let graph = Graph::decode(&path).unwrap();
             let index_spec2 = graph.get_index_spec().unwrap();
 
             assert_eq!(index_spec, index_spec2);
@@ -982,7 +924,7 @@ mod test_index {
 
         #[test]
         fn test_get_index_spec_loaded_index_zip() {
-            let graph = init_graph(Graph::new());
+            let graph = init_graph();
 
             let index_spec = IndexSpecBuilder::new(graph.clone())
                 .with_node_metadata(vec!["y"])
@@ -997,7 +939,7 @@ mod test_index {
             let binding = TempDir::new().unwrap();
             let path = binding.path();
             let folder = GraphFolder::new_as_zip(path);
-            graph.encode(folder.root_folder).unwrap();
+            graph.encode(folder).unwrap();
 
             let graph = Graph::decode(path).unwrap();
             assert_eq!(index_spec, graph.get_index_spec().unwrap());
@@ -1029,7 +971,7 @@ mod test_index {
         where
             F: Fn(&Graph, IndexSpec) -> Result<(), GraphError>,
         {
-            let graph = init_graph(Graph::new());
+            let graph = init_graph();
 
             let index_spec = IndexSpecBuilder::new(graph.clone())
                 .with_node_metadata(vec!["y"])
@@ -1043,7 +985,7 @@ mod test_index {
             assert_eq!(search_nodes(&graph, filter.clone()), vec!["pometry"]);
 
             let node = graph
-                .add_node(1, "shivam", [("p1", 100u64)], Some("fire_nation"))
+                .add_node(1, "shivam", [("p1", 100u64)], Some("fire_nation"), None)
                 .unwrap();
             assert_eq!(index_spec, graph.get_index_spec().unwrap());
 
@@ -1065,7 +1007,7 @@ mod test_index {
         where
             F: Fn(&Graph, IndexSpec) -> Result<(), GraphError>,
         {
-            let graph = init_graph(Graph::new());
+            let graph = init_graph();
 
             let index_spec = IndexSpecBuilder::new(graph.clone())
                 .with_node_metadata(vec!["y"])
diff --git a/raphtory/src/search/node_index.rs b/raphtory/src/search/node_index.rs
index fa2a6275cc..986fdd77b2 100644
--- a/raphtory/src/search/node_index.rs
+++ b/raphtory/src/search/node_index.rs
@@ -1,8 +1,5 @@
 use crate::{
-    core::{
-        entities::VID,
-        storage::timeindex::{AsTime, EventTime},
-    },
+    core::{entities::VID, storage::timeindex::EventTime},
     db::{api::view::IndexSpec, graph::node::NodeView},
     errors::GraphError,
     prelude::*,
@@ -13,7 +10,6 @@ use crate::{
     },
 };
 use ahash::HashSet;
-use raphtory_api::core::storage::{arc_str::ArcStr, dict_mapper::MaybeNew};
 use raphtory_storage::graph::graph::GraphStorage;
 use rayon::{iter::IntoParallelIterator, prelude::ParallelIterator};
 use std::{
@@ -194,14 +190,14 @@ impl NodeIndex {
         &self,
         node_id: u64,
         node_name: String,
-        node_type: Option<ArcStr>,
+        node_type: Option<&str>,
     ) -> TantivyDocument {
         let mut document = TantivyDocument::new();
         document.add_u64(self.node_id_field, node_id);
         document.add_text(self.node_name_field, node_name.clone());
         document.add_text(self.node_name_tokenized_field, node_name);
         if let Some(node_type) = node_type {
-            document.add_text(self.node_type_field, node_type.clone());
+            document.add_text(self.node_type_field, node_type);
             document.add_text(self.node_type_tokenized_field, node_type);
         }
         document
@@ -216,11 +212,7 @@ impl NodeIndex {
         let node_name = node.name();
         let node_type = node.node_type();
 
-        let node_doc = self.create_document(node_id, node_name.clone(), node_type.clone());
-        // println!(
-        //     "Indexing Node Document: {}",
-        //     node_doc.to_json(&self.entity_index.index.schema()) // assumes `self.index` has `schema() -> &Schema`
-        // );
+        let node_doc = self.create_document(node_id, node_name.clone(), node_type.as_deref());
         writer.add_document(node_doc)?;
 
         Ok(())
@@ -255,31 +247,29 @@ impl NodeIndex {
         Ok(())
     }
 
+    pub(crate) fn add_new_node(
+        &self,
+        node_id: VID,
+        name: String,
+        node_type: Option<&str>,
+    ) -> Result<(), GraphError> {
+        let vid_u64 = node_id.as_u64(); // Check if the node document is already in the index,
+                                        // if it does skip adding a new doc for same node
+
+        let mut writer = self.entity_index.index.writer(100_000_000)?;
+        let node_doc = self.create_document(vid_u64, name, node_type);
+        writer.add_document(node_doc)?;
+        writer.commit()?;
+        Ok(())
+    }
+
     pub(crate) fn add_node_update(
         &self,
-        graph: &GraphStorage,
         t: EventTime,
-        node_id: MaybeNew<VID>,
+        node_id: VID,
         props: &[(usize, Prop)],
     ) -> Result<(), GraphError> {
-        let node = graph
-            .node(VID(node_id.inner().as_u64() as usize))
-            .expect("Node for internal id should exist.")
-            .at(t.t());
-        let vid_u64 = node_id.inner().as_u64();
-
-        // Check if the node document is already in the index,
-        // if it does skip adding a new doc for same node
-        node_id
-            .if_new(|_| {
-                let mut writer = self.entity_index.index.writer(100_000_000)?;
-                let node_doc = self.create_document(vid_u64, node.name(), node.node_type());
-                writer.add_document(node_doc)?;
-                writer.commit()?;
-                Ok::<(), GraphError>(())
-            })
-            .transpose()?;
-
+        let vid_u64 = node_id.as_u64();
         let indexes = self.entity_index.temporal_property_indexes.read_recursive();
         for (prop_id, prop_value) in indexed_props(props, &indexes) {
             if let Some(index) = &indexes[prop_id] {
diff --git a/raphtory/src/search/property_index.rs b/raphtory/src/search/property_index.rs
index 33a2094f45..7fe315e568 100644
--- a/raphtory/src/search/property_index.rs
+++ b/raphtory/src/search/property_index.rs
@@ -3,7 +3,10 @@ use crate::{
     prelude::*,
     search::{fields, get_reader, new_index, TOKENIZER},
 };
-use raphtory_api::core::{entities::properties::prop::PropType, storage::timeindex::EventTime};
+use raphtory_api::core::{
+    entities::{properties::prop::PropType, LayerId},
+    storage::timeindex::EventTime,
+};
 use std::{fs, path::PathBuf, sync::Arc};
 use tantivy::{
     collector::TopDocs,
@@ -253,7 +256,7 @@ impl PropertyIndex {
         field_entity_id: Field,
         entity_id: u64,
         time: Option<EventTime>,
-        layer_id: Option<usize>,
+        layer_id: Option<LayerId>,
         prop_value: &Prop,
     ) -> tantivy::Result<TantivyDocument> {
         let field_property = Field::from_field_id(0);
@@ -269,7 +272,7 @@ impl PropertyIndex {
         }
 
         if let (Some(layer_id), Some(field_layer_id)) = (layer_id, self.layer_field) {
-            document.add_u64(field_layer_id, layer_id as u64);
+            document.add_u64(field_layer_id, layer_id.0 as u64);
         }
 
         Self::add_property_value_to_doc(&mut document, field_property, prop_value);
@@ -299,7 +302,7 @@ impl PropertyIndex {
     pub(crate) fn create_edge_metadata_document(
         &self,
         edge_id: u64,
-        layer_id: usize,
+        layer_id: LayerId,
         prop_value: &Prop,
     ) -> tantivy::Result<TantivyDocument> {
         let field_edge_id = self.entity_id_field;
@@ -310,7 +313,7 @@ impl PropertyIndex {
         &self,
         time: EventTime,
         edge_id: u64,
-        layer_id: usize,
+        layer_id: LayerId,
         prop_value: &Prop,
     ) -> tantivy::Result<TantivyDocument> {
         let field_edge_id = self.entity_id_field;
diff --git a/raphtory/src/search/searcher.rs b/raphtory/src/search/searcher.rs
index 2cdde22b84..a77661c4af 100644
--- a/raphtory/src/search/searcher.rs
+++ b/raphtory/src/search/searcher.rs
@@ -109,6 +109,7 @@ mod search_tests {
                     "pometry",
                     [("p1", "tango".into_prop())],
                     Some("fire_nation"),
+                    None,
                 )
                 .unwrap();
             graph
@@ -117,6 +118,7 @@ mod search_tests {
                     "shivam_kapoor",
                     [("p1", "charlie_bravo".into_prop())],
                     Some("fire_nation"),
+                    None,
                 )
                 .unwrap();
 
@@ -218,9 +220,9 @@ mod search_tests {
                 )
                 .unwrap();
 
-            graph.add_node(1, "shivam", NO_PROPS, None).unwrap();
-            graph.add_node(1, "raphtory", NO_PROPS, None).unwrap();
-            graph.add_node(1, "pometry", NO_PROPS, None).unwrap();
+            graph.add_node(1, "shivam", NO_PROPS, None, None).unwrap();
+            graph.add_node(1, "raphtory", NO_PROPS, None, None).unwrap();
+            graph.add_node(1, "pometry", NO_PROPS, None, None).unwrap();
 
             graph.create_index_in_ram().unwrap();
 
@@ -281,6 +283,7 @@ mod search_tests {
     #[ignore = "this test is for experiments with the jira graph"]
     fn load_jira_graph() -> Result<(), GraphError> {
         global_info_logger();
+
         let graph = Graph::decode("/tmp/graphs/jira").expect("failed to load graph");
         assert!(graph.count_nodes() > 0);
 
diff --git a/raphtory/src/serialise/graph_folder.rs b/raphtory/src/serialise/graph_folder.rs
new file mode 100644
index 0000000000..45a5d5cbfd
--- /dev/null
+++ b/raphtory/src/serialise/graph_folder.rs
@@ -0,0 +1,887 @@
+//! Raphtory container format for managing graph data.
+//!
+//! Folder structure:
+//!
+//! GraphFolder
+//! ├── .raph         # Metadata file (json: {path: "data{id}"}) pointing at the current data folder
+//! └── data{id}/    # Data folder (incremental id for atomic replacement)
+//!     ├── .meta         # Metadata file (json: {path: "graph{id}", meta: {}}) pointing at the current graph folder
+//!     ├── graph{id}/   # Graph data (incremental id for atomic replacement)
+//!     ├── index/        # Search indexes (optional)
+//!     └── vectors/      # Vector embeddings (optional)
+
+use crate::{
+    db::api::view::internal::GraphView, errors::GraphError, prelude::ParquetEncoder,
+    serialise::metadata::GraphMetadata,
+};
+use itertools::Itertools;
+use raphtory_api::core::input::input_node::parse_u64_strict;
+use serde::{Deserialize, Serialize};
+use std::{
+    fs::{self, File},
+    io::{self, ErrorKind, Read, Seek, Write},
+    path::{Path, PathBuf},
+};
+use walkdir::WalkDir;
+use zip::{write::FileOptions, ZipArchive, ZipWriter};
+
+/// Metadata file that stores path to the data folder.
+pub const ROOT_META_PATH: &str = ".raph";
+
+/// Outer most directory containing all data.
+pub const DATA_PATH: &str = "data";
+pub const DEFAULT_DATA_PATH: &str = "data0";
+
+/// Metadata file that stores path to the graph folder and graph metadata.
+pub const GRAPH_META_PATH: &str = ".meta";
+
+/// Directory that stores graph data.
+pub const GRAPH_PATH: &str = "graph";
+pub const DEFAULT_GRAPH_PATH: &str = "graph0";
+
+/// Directory that stores search indexes.
+pub const INDEX_PATH: &str = "index";
+
+/// Directory that stores vector embeddings of the graph.
+pub const VECTORS_PATH: &str = "vectors";
+
+/// Temporary metadata file for atomic replacement.
+pub const DIRTY_PATH: &str = ".dirty";
+
+pub(crate) fn valid_path_pointer(relative_path: &str, prefix: &str) -> Result<(), GraphError> {
+    relative_path
+        .strip_prefix(prefix) // should have the prefix
+        .and_then(parse_u64_strict) // the remainder should be the id
+        .ok_or_else(|| GraphError::InvalidRelativePath(relative_path.to_string()))?;
+    Ok(())
+}
+
+fn read_path_from_file(mut file: impl Read, prefix: &str) -> Result<String, GraphError> {
+    let mut value = String::new();
+    file.read_to_string(&mut value)?;
+    let path: RelativePath = serde_json::from_str(&value)?;
+    valid_path_pointer(&path.path, prefix)?;
+    Ok(path.path)
+}
+
+pub fn read_path_pointer(
+    base_path: &Path,
+    file_name: &str,
+    prefix: &str,
+) -> Result<Option<String>, GraphError> {
+    let file = match File::open(base_path.join(file_name)) {
+        Ok(file) => file,
+        Err(error) => {
+            return match error.kind() {
+                ErrorKind::NotFound => Ok(None),
+                _ => Err(error.into()),
+            }
+        }
+    };
+    let path = read_path_from_file(file, prefix)?;
+    Ok(Some(path))
+}
+
+pub fn make_path_pointer(
+    base_path: &Path,
+    file_name: &str,
+    prefix: &str,
+) -> Result<String, io::Error> {
+    let mut id = read_path_pointer(base_path, file_name, prefix)?
+        .and_then(|path| {
+            path.strip_prefix(prefix)
+                .and_then(|id| id.parse::<usize>().ok())
+        })
+        .map_or(0, |id| id + 1);
+
+    let mut path = format!("{prefix}{id}");
+    while base_path.join(&path).exists() {
+        id += 1;
+        path = format!("{prefix}{id}");
+    }
+    Ok(path)
+}
+
+pub fn read_or_default_path_pointer(
+    base_path: &Path,
+    file_name: &str,
+    prefix: &str,
+) -> Result<String, GraphError> {
+    Ok(read_path_pointer(base_path, file_name, prefix)?.unwrap_or_else(|| prefix.to_owned() + "0"))
+}
+
+pub fn get_zip_data_path<R: Read + Seek>(zip: &mut ZipArchive<R>) -> Result<String, GraphError> {
+    let file = zip.by_name(ROOT_META_PATH)?;
+    Ok(read_path_from_file(file, DATA_PATH)?)
+}
+
+pub fn get_zip_graph_path<R: Read + Seek>(zip: &mut ZipArchive<R>) -> Result<String, GraphError> {
+    let mut path = get_zip_data_path(zip)?;
+    let graph_path = get_zip_graph_path_name(zip, path.clone())?;
+    path.push('/');
+    path.push_str(&graph_path);
+    Ok(path)
+}
+
+pub fn get_zip_graph_path_name<R: Read + Seek>(
+    zip: &mut ZipArchive<R>,
+    mut data_path: String,
+) -> Result<String, GraphError> {
+    data_path.push('/');
+    data_path.push_str(GRAPH_META_PATH);
+    let graph_path = read_path_from_file(zip.by_name(&data_path)?, GRAPH_PATH)?;
+    Ok(graph_path)
+}
+
+pub fn get_zip_meta_path<R: Read + Seek>(zip: &mut ZipArchive<R>) -> Result<String, GraphError> {
+    let mut path = get_zip_data_path(zip)?;
+    path.push('/');
+    path.push_str(GRAPH_META_PATH);
+    Ok(path)
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct RelativePath {
+    pub path: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Metadata {
+    pub path: String,
+    pub meta: GraphMetadata,
+}
+
+pub trait GraphPaths {
+    fn root(&self) -> &Path;
+
+    fn root_meta_path(&self) -> PathBuf {
+        self.root().join(ROOT_META_PATH)
+    }
+
+    fn data_path(&self) -> Result<InnerGraphFolder, GraphError> {
+        Ok(InnerGraphFolder {
+            path: self.root().join(self.relative_data_path()?),
+        })
+    }
+
+    fn vectors_path(&self) -> Result<PathBuf, GraphError> {
+        let mut path = self.data_path()?.path;
+        path.push(VECTORS_PATH);
+        Ok(path)
+    }
+
+    fn index_path(&self) -> Result<PathBuf, GraphError> {
+        let mut path = self.data_path()?.path;
+        path.push(INDEX_PATH);
+        Ok(path)
+    }
+
+    fn graph_path(&self) -> Result<PathBuf, GraphError> {
+        let mut path = self.data_path()?.path;
+        path.push(self.relative_graph_path()?);
+        Ok(path)
+    }
+
+    fn meta_path(&self) -> Result<PathBuf, GraphError> {
+        let mut path = self.data_path()?.path;
+        path.push(GRAPH_META_PATH);
+        Ok(path)
+    }
+
+    fn is_zip(&self) -> bool {
+        self.root().is_file()
+    }
+
+    fn read_zip(&self) -> Result<ZipArchive<File>, GraphError> {
+        if self.is_zip() {
+            let file = File::open(self.root())?;
+            let archive = ZipArchive::new(file)?;
+            Ok(archive)
+        } else {
+            Err(GraphError::NotAZip)
+        }
+    }
+
+    fn relative_data_path(&self) -> Result<String, GraphError> {
+        let path = if self.is_zip() {
+            let mut zip = self.read_zip()?;
+            get_zip_data_path(&mut zip)?
+        } else {
+            read_or_default_path_pointer(self.root(), ROOT_META_PATH, DATA_PATH)?
+        };
+        Ok(path)
+    }
+
+    fn relative_graph_path(&self) -> Result<String, GraphError> {
+        if self.is_zip() {
+            let mut zip = self.read_zip()?;
+            let data_path = get_zip_data_path(&mut zip)?;
+            get_zip_graph_path_name(&mut zip, data_path)
+        } else {
+            let data_path = self.data_path()?;
+            read_or_default_path_pointer(data_path.as_ref(), GRAPH_META_PATH, GRAPH_PATH)
+        }
+    }
+
+    fn read_metadata(&self) -> Result<GraphMetadata, GraphError> {
+        let mut json = String::new();
+        if self.is_zip() {
+            let mut zip = self.read_zip()?;
+            let path = get_zip_meta_path(&mut zip)?;
+            let mut zip_file = zip.by_name(&path)?;
+            zip_file.read_to_string(&mut json)?;
+        } else {
+            let mut file = File::open(self.meta_path()?)?;
+            file.read_to_string(&mut json)?;
+        }
+        let metadata: Metadata = serde_json::from_str(&json)?;
+        Ok(metadata.meta)
+    }
+
+    fn write_metadata(&self, graph: impl GraphView) -> Result<(), GraphError> {
+        let graph_path = self.relative_graph_path()?;
+        let metadata = GraphMetadata::from_graph(graph);
+        let meta = Metadata {
+            path: graph_path,
+            meta: metadata,
+        };
+        let tmp_path = self.data_path()?.path.join(".tmp");
+        let tmp_file = File::create(&tmp_path)?;
+        serde_json::to_writer(tmp_file, &meta)?;
+        let path = self.meta_path()?;
+        fs::rename(tmp_path, path)?;
+        Ok(())
+    }
+
+    /// Returns true if folder is occupied by a graph.
+    fn is_reserved(&self) -> bool {
+        self.meta_path().map_or(false, |path| path.exists())
+    }
+
+    /// Initialise the data folder and metadata pointer
+    fn init(&self) -> Result<(), GraphError> {
+        if self.root().is_dir() {
+            let non_empty = self.root().read_dir()?.next().is_some();
+            if non_empty {
+                return Err(GraphError::NonEmptyGraphFolder(self.root().into()));
+            }
+        } else {
+            fs::create_dir_all(self.root())?
+        }
+
+        // Create the data folder and have the root metadata file point to it.
+        let data_path = self.relative_data_path()?;
+        fs::create_dir(self.root().join(&data_path))?;
+        fs::write(
+            self.root_meta_path(),
+            serde_json::to_string(&RelativePath { path: data_path })?,
+        )?;
+
+        // Create the graph folder inside the data folder.
+        let graph_path = self.graph_path()?;
+        fs::create_dir(&graph_path)?;
+
+        Ok(())
+    }
+}
+
+impl<P: AsRef<Path> + ?Sized> GraphPaths for P {
+    fn root(&self) -> &Path {
+        self.as_ref()
+    }
+}
+
+#[derive(Clone, Debug, PartialOrd, PartialEq, Ord, Eq)]
+pub struct GraphFolder {
+    root_folder: PathBuf,
+    pub(crate) write_as_zip_format: bool,
+}
+
+impl GraphPaths for GraphFolder {
+    fn root(&self) -> &Path {
+        &self.root_folder
+    }
+}
+
+impl GraphFolder {
+    pub fn new_as_zip(path: impl AsRef<Path>) -> Self {
+        let folder: GraphFolder = path.into();
+        Self {
+            write_as_zip_format: true,
+            ..folder
+        }
+    }
+
+    /// Reserve a folder, marking it as occupied by a graph.
+    /// Returns an error if the folder has data.
+    pub fn init_write(self) -> Result<WriteableGraphFolder, GraphError> {
+        if self.write_as_zip_format {
+            return Err(GraphError::ZippedGraphCannotBeSwapped);
+        }
+        let relative_data_path = self.relative_data_path()?;
+        let meta = serde_json::to_string(&RelativePath {
+            path: relative_data_path.clone(),
+        })?;
+        self.ensure_clean_root_dir()?;
+        let metapath = self.root_folder.join(DIRTY_PATH);
+        let mut path_file = File::create_new(&metapath)?;
+        path_file.write_all(meta.as_bytes())?;
+        fs::create_dir_all(self.root_folder.join(relative_data_path))?;
+        Ok(WriteableGraphFolder {
+            path: self.root_folder,
+        })
+    }
+
+    /// Prepare a graph folder for atomically swapping the data contents.
+    /// This returns an error if the folder is set to write as Zip.
+    ///
+    /// If a swap is already in progress (i.e., `.dirty` file exists) it is aborted and
+    /// the contents of the corresponding folder are deleted.
+    pub fn init_swap(self) -> Result<WriteableGraphFolder, GraphError> {
+        if self.write_as_zip_format {
+            return Err(GraphError::ZippedGraphCannotBeSwapped);
+        }
+        let old_swap = match read_path_pointer(self.root(), DIRTY_PATH, DATA_PATH) {
+            Ok(path) => path,
+            Err(_) => {
+                fs::remove_file(self.root_folder.join(DIRTY_PATH))?; // dirty file is corrupted, clean it up
+                None
+            }
+        };
+
+        fs::create_dir_all(self.root())?;
+
+        let swap_path = match old_swap {
+            Some(relative_path) => {
+                let swap_path = self.root_folder.join(relative_path);
+                if swap_path.exists() {
+                    fs::remove_dir_all(&swap_path)?;
+                }
+                swap_path
+            }
+            None => {
+                let new_relative_data_path =
+                    make_path_pointer(self.root(), ROOT_META_PATH, DATA_PATH)?;
+                let new_data_path = self.root_folder.join(&new_relative_data_path);
+                let meta = serde_json::to_string(&RelativePath {
+                    path: new_relative_data_path,
+                })?;
+                let mut dirty_file = File::create_new(self.root_folder.join(DIRTY_PATH))?;
+                dirty_file.write_all(meta.as_bytes())?;
+                dirty_file.sync_all()?;
+                new_data_path
+            }
+        };
+        fs::create_dir_all(swap_path)?;
+        Ok(WriteableGraphFolder {
+            path: self.root_folder,
+        })
+    }
+
+    /// Clears the folder of any contents.
+    pub fn clear(&self) -> Result<(), GraphError> {
+        if self.is_zip() {
+            return Err(GraphError::IOErrorMsg(
+                "Cannot clear a zip folder".to_string(),
+            ));
+        }
+
+        fs::remove_dir_all(&self.root_folder)?;
+        fs::create_dir_all(&self.root_folder)?;
+        Ok(())
+    }
+
+    pub fn get_zip_graph_prefix(&self) -> Result<String, GraphError> {
+        if self.is_zip() {
+            let mut zip = self.read_zip()?;
+            Ok([get_zip_data_path(&mut zip)?, get_zip_graph_path(&mut zip)?].join("/"))
+        } else {
+            let data_path = read_or_default_path_pointer(self.root(), ROOT_META_PATH, DATA_PATH)?;
+            let graph_path = read_or_default_path_pointer(
+                &self.root().join(&data_path),
+                GRAPH_META_PATH,
+                GRAPH_PATH,
+            )?;
+            Ok([data_path, graph_path].join("/"))
+        }
+    }
+
+    fn ensure_clean_root_dir(&self) -> Result<(), GraphError> {
+        if self.root_folder.exists() {
+            let non_empty = self.root_folder.read_dir()?.next().is_some();
+            if non_empty {
+                return Err(GraphError::NonEmptyGraphFolder(self.root_folder.clone()));
+            }
+        } else {
+            fs::create_dir(&self.root_folder)?
+        }
+
+        Ok(())
+    }
+
+    pub fn is_disk_graph(&self) -> Result<bool, GraphError> {
+        let meta = self.read_metadata()?;
+        Ok(meta.is_diskgraph)
+    }
+
+    /// Creates a zip file from the folder.
+    pub fn zip_from_folder<W: Write + Seek>(&self, mut writer: W) -> Result<(), GraphError> {
+        if self.is_zip() {
+            let mut reader = File::open(&self.root_folder)?;
+            io::copy(&mut reader, &mut writer)?;
+        } else {
+            let mut zip = ZipWriter::new(writer);
+            for entry in WalkDir::new(&self.root_folder)
+                .into_iter()
+                .filter_map(Result::ok)
+            {
+                let path = entry.path();
+                let rel_path = path.strip_prefix(&self.root_folder).map_err(|e| {
+                    GraphError::IOErrorMsg(format!("Failed to strip prefix from path: {}", e))
+                })?;
+
+                let zip_entry_name = rel_path
+                    .components()
+                    .map(|name| name.as_os_str().to_string_lossy())
+                    .join("/");
+
+                if path.is_file() {
+                    zip.start_file::<_, ()>(zip_entry_name, FileOptions::default())?;
+
+                    let mut file = File::open(path)?;
+                    std::io::copy(&mut file, &mut zip)?;
+                } else if path.is_dir() && !zip_entry_name.is_empty() {
+                    // Add empty directories to the zip
+                    zip.add_directory::<_, ()>(zip_entry_name, FileOptions::default())?;
+                }
+            }
+
+            zip.finish()?;
+        }
+        Ok(())
+    }
+
+    pub fn unzip_to_folder<R: Read + Seek>(&self, reader: R) -> Result<(), GraphError> {
+        self.ensure_clean_root_dir()?;
+        let mut archive = ZipArchive::new(reader)?;
+        archive.extract(self.root())?;
+        Ok(())
+    }
+}
+
+#[must_use]
+#[derive(Debug, Clone, PartialOrd, PartialEq, Ord, Eq)]
+pub struct WriteableGraphFolder {
+    path: PathBuf,
+}
+
+impl GraphPaths for WriteableGraphFolder {
+    fn root(&self) -> &Path {
+        &self.path
+    }
+
+    fn relative_data_path(&self) -> Result<String, GraphError> {
+        let path = read_path_pointer(self.root(), DIRTY_PATH, DATA_PATH)?
+            .ok_or(GraphError::NoWriteInProgress)?;
+        Ok(path)
+    }
+
+    fn relative_graph_path(&self) -> Result<String, GraphError> {
+        let path =
+            read_or_default_path_pointer(&self.data_path()?.as_ref(), GRAPH_META_PATH, GRAPH_PATH)?;
+        Ok(path)
+    }
+
+    fn init(&self) -> Result<(), GraphError> {
+        Ok(())
+    }
+}
+
+impl WriteableGraphFolder {
+    /// Finalise an in-progress write by atomically renaming the '.dirty' file to '.raph'
+    /// and cleaning up any old data if it exists.
+    ///
+    /// This operation returns an error if there is no write in progress.
+    pub fn finish(self) -> Result<GraphFolder, GraphError> {
+        let old_data = read_path_pointer(self.root(), ROOT_META_PATH, DATA_PATH)?;
+        fs::rename(
+            self.root().join(DIRTY_PATH),
+            self.root().join(ROOT_META_PATH),
+        )?;
+        if let Some(old_data) = old_data {
+            let old_data_path = self.root().join(old_data);
+            if old_data_path.is_dir() {
+                fs::remove_dir_all(old_data_path)?;
+            }
+        }
+        Ok(GraphFolder {
+            root_folder: self.path,
+            write_as_zip_format: false,
+        })
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct InnerGraphFolder {
+    path: PathBuf,
+}
+
+impl AsRef<Path> for InnerGraphFolder {
+    fn as_ref(&self) -> &Path {
+        &self.path
+    }
+}
+
+impl InnerGraphFolder {
+    pub fn write_metadata(&self, graph: impl GraphView) -> Result<(), GraphError> {
+        let graph_path = self.relative_graph_path()?;
+        let metadata = GraphMetadata::from_graph(graph);
+        let meta = Metadata {
+            path: graph_path,
+            meta: metadata,
+        };
+        let path = self.meta_path();
+        let file = File::create(&path)?;
+        Ok(serde_json::to_writer(file, &meta)?)
+    }
+
+    pub fn read_metadata(&self) -> Result<GraphMetadata, GraphError> {
+        let mut json = String::new();
+        let mut file = File::open(self.meta_path())?;
+        file.read_to_string(&mut json)?;
+        let metadata: Metadata = serde_json::from_str(&json)?;
+        Ok(metadata.meta)
+    }
+
+    pub fn replace_graph(
+        &self,
+        graph: impl ParquetEncoder + GraphView + std::fmt::Debug,
+    ) -> Result<(), GraphError> {
+        let data_path = self.as_ref();
+        let old_relative_graph_path = self.relative_graph_path()?;
+        let old_graph_path = self.path.join(&old_relative_graph_path);
+        let meta = GraphMetadata::from_graph(&graph);
+        let new_relative_graph_path = make_path_pointer(data_path, GRAPH_META_PATH, GRAPH_PATH)?;
+        graph.encode_parquet(data_path.join(&new_relative_graph_path))?;
+
+        let dirty_path = data_path.join(DIRTY_PATH);
+        fs::write(
+            &dirty_path,
+            &serde_json::to_vec(&Metadata {
+                path: new_relative_graph_path.clone(),
+                meta,
+            })?,
+        )?;
+        fs::rename(&dirty_path, data_path.join(GRAPH_META_PATH))?;
+        if new_relative_graph_path != old_relative_graph_path {
+            fs::remove_dir_all(old_graph_path)?;
+        }
+        Ok(())
+    }
+    pub fn vectors_path(&self) -> PathBuf {
+        self.path.join(VECTORS_PATH)
+    }
+
+    pub fn index_path(&self) -> PathBuf {
+        self.path.join(INDEX_PATH)
+    }
+
+    pub fn meta_path(&self) -> PathBuf {
+        self.path.join(GRAPH_META_PATH)
+    }
+
+    pub fn relative_graph_path(&self) -> Result<String, GraphError> {
+        let relative = read_or_default_path_pointer(&self.path, GRAPH_META_PATH, GRAPH_PATH)?;
+        Ok(relative)
+    }
+
+    pub fn graph_path(&self) -> Result<PathBuf, GraphError> {
+        Ok(self.path.join(self.relative_graph_path()?))
+    }
+
+    fn ensure_clean_root_dir(&self) -> Result<(), GraphError> {
+        if self.as_ref().exists() {
+            let non_empty = self.as_ref().read_dir()?.next().is_some();
+            if non_empty {
+                return Err(GraphError::NonEmptyGraphFolder(self.as_ref().to_path_buf()));
+            }
+        } else {
+            fs::create_dir_all(self)?
+        }
+        Ok(())
+    }
+
+    /// Extracts a zip file to the folder.
+    pub fn unzip_to_folder<R: Read + Seek>(&self, reader: R) -> Result<(), GraphError> {
+        self.ensure_clean_root_dir()?;
+
+        let mut zip = ZipArchive::new(reader)?;
+        let data_dir = get_zip_data_path(&mut zip)?;
+
+        for i in 0..zip.len() {
+            let mut file = zip.by_index(i)?;
+            let zip_entry_name = match file.enclosed_name() {
+                Some(name) => name,
+                None => continue,
+            };
+            if let Ok(inner_path) = zip_entry_name.strip_prefix(&data_dir) {
+                let out_path = self.as_ref().join(inner_path);
+                if file.is_dir() {
+                    std::fs::create_dir_all(&out_path)?;
+                } else {
+                    // Create any parent directories
+                    if let Some(parent) = out_path.parent() {
+                        std::fs::create_dir_all(parent)?;
+                    }
+
+                    let mut out_file = std::fs::File::create(&out_path)?;
+                    std::io::copy(&mut file, &mut out_file)?;
+                }
+            }
+        }
+
+        Ok(())
+    }
+}
+
+impl<P: AsRef<Path>> From<P> for GraphFolder {
+    fn from(value: P) -> Self {
+        let path: &Path = value.as_ref();
+        Self {
+            root_folder: path.to_path_buf(),
+            write_as_zip_format: false,
+        }
+    }
+}
+
+impl From<&GraphFolder> for GraphFolder {
+    fn from(value: &GraphFolder) -> Self {
+        value.clone()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{
+        db::graph::graph::assert_graph_equal, prelude::*, serialise::serialise::StableDecode,
+    };
+
+    // /// Verify that the metadata is re-created if it does not exist.
+    // #[test]
+    // #[ignore = "Need to think about how to deal with reading old format"]
+    // fn test_read_metadata_from_noninitialized_zip() {
+    //     global_info_logger();
+    //
+    //     let graph = Graph::new();
+    //     graph.add_node(0, 0, NO_PROPS, None).unwrap();
+    //
+    //     let tmp_dir = tempfile::TempDir::new().unwrap();
+    //     let zip_path = tmp_dir.path().join("graph.zip");
+    //     let folder = GraphFolder::new_as_zip(&zip_path);
+    //     graph.encode(&folder).unwrap();
+    //
+    //     // Remove the metadata file from the zip to simulate a noninitialized zip
+    //     remove_metadata_from_zip(&zip_path);
+    //
+    //     // Should fail because the metadata file is not present
+    //     let err = folder.try_read_metadata();
+    //     assert!(err.is_err());
+    //
+    //     // Should re-create the metadata file
+    //     let result = folder.read_metadata().unwrap();
+    //     assert_eq!(
+    //         result,
+    //         GraphMetadata {
+    //             node_count: 1,
+    //             edge_count: 0,
+    //             metadata: vec![],
+    //             graph_type: GraphType::EventGraph,
+    //             is_diskgraph: false
+    //         }
+    //     );
+    // }
+
+    // /// Helper function to remove the metadata file from a zip
+    // fn remove_metadata_from_zip(zip_path: &Path) {
+    //     let mut zip_file = std::fs::File::open(&zip_path).unwrap();
+    //     let mut zip_archive = zip::ZipArchive::new(&mut zip_file).unwrap();
+    //     let mut temp_zip = tempfile::NamedTempFile::new().unwrap();
+    //
+    //     // Scope for the zip writer
+    //     {
+    //         let mut zip_writer = zip::ZipWriter::new(&mut temp_zip);
+    //
+    //         for i in 0..zip_archive.len() {
+    //             let mut file = zip_archive.by_index(i).unwrap();
+    //
+    //             // Copy all files except the metadata file
+    //             if file.name() != META_PATH {
+    //                 zip_writer
+    //                     .start_file::<_, ()>(file.name(), FileOptions::default())
+    //                     .unwrap();
+    //                 std::io::copy(&mut file, &mut zip_writer).unwrap();
+    //             }
+    //         }
+    //
+    //         zip_writer.finish().unwrap();
+    //     }
+    //
+    //     std::fs::copy(temp_zip.path(), &zip_path).unwrap();
+    // }
+
+    // /// Verify that the metadata is re-created if it does not exist.
+    // #[test]
+    // #[ignore = "Need to think about how to handle reading from old format"]
+    // fn test_read_metadata_from_noninitialized_folder() {
+    //     global_info_logger();
+    //
+    //     let graph = Graph::new();
+    //     graph.add_node(0, 0, NO_PROPS, None).unwrap();
+    //
+    //     let temp_folder = tempfile::TempDir::new().unwrap();
+    //     let folder = GraphFolder::from(temp_folder.path());
+    //     graph.encode(&folder).unwrap();
+    //
+    //     // Remove the metadata file
+    //     std::fs::remove_file(folder.get_meta_path()).unwrap();
+    //
+    //     // Should fail because the metadata file is not present
+    //     let err = folder.try_read_metadata();
+    //     assert!(err.is_err());
+    //
+    //     // Should re-create the metadata file
+    //     let result = folder.read_metadata().unwrap();
+    //     assert_eq!(
+    //         result,
+    //         GraphMetadata {
+    //             node_count: 1,
+    //             edge_count: 0,
+    //             metadata: vec![],
+    //             graph_type: GraphType::EventGraph,
+    //             is_diskgraph: false
+    //         }
+    //     );
+    // }
+    #[test]
+    fn test_zip_from_folder() {
+        let graph = Graph::new();
+        graph.add_node(0, 0, NO_PROPS, None, None).unwrap();
+        graph.add_node(1, 1, NO_PROPS, None, None).unwrap();
+        graph.add_edge(0, 0, 1, NO_PROPS, None).unwrap();
+
+        // Create a regular folder and encode the graph
+        let temp_folder = tempfile::TempDir::new().unwrap();
+        let initial_folder = GraphFolder::from(temp_folder.path().join("initial"));
+        graph.encode(&initial_folder).unwrap();
+
+        assert!(initial_folder.graph_path().unwrap().exists());
+        assert!(initial_folder.meta_path().unwrap().exists());
+
+        // Create a zip file from the folder
+        let output_zip_path = temp_folder.path().join("output.zip");
+        let output_zip_file = std::fs::File::create(&output_zip_path).unwrap();
+        initial_folder.zip_from_folder(output_zip_file).unwrap();
+
+        assert!(output_zip_path.exists());
+
+        // Verify the output zip contains the same graph
+        let zip_folder = GraphFolder::new_as_zip(&output_zip_path);
+        let decoded_graph = Graph::decode(&zip_folder).unwrap();
+
+        assert_graph_equal(&graph, &decoded_graph);
+    }
+
+    #[test]
+    fn test_zip_from_zip() {
+        let graph = Graph::new();
+        graph.add_node(0, 0, NO_PROPS, None, None).unwrap();
+        graph.add_node(1, 1, NO_PROPS, None, None).unwrap();
+        graph.add_edge(0, 0, 1, NO_PROPS, None).unwrap();
+
+        // Create an initial zip file
+        let temp_folder = tempfile::TempDir::new().unwrap();
+        let initial_zip_path = temp_folder.path().join("initial.zip");
+        let initial_folder = GraphFolder::new_as_zip(&initial_zip_path);
+        graph.encode(&initial_folder).unwrap();
+
+        assert!(initial_zip_path.exists());
+
+        // Create a new zip file from the existing zip
+        let output_zip_path = temp_folder.path().join("output.zip");
+        let output_zip_file = std::fs::File::create(&output_zip_path).unwrap();
+        initial_folder.zip_from_folder(output_zip_file).unwrap();
+
+        assert!(output_zip_path.exists());
+
+        // Verify zip file sizes
+        let initial_size = std::fs::metadata(&initial_zip_path).unwrap().len();
+        let output_size = std::fs::metadata(&output_zip_path).unwrap().len();
+        assert_eq!(initial_size, output_size);
+
+        // Verify the output zip contains the same graph
+        let zip_folder = GraphFolder::new_as_zip(&output_zip_path);
+        let decoded_graph = Graph::decode(&zip_folder).unwrap();
+
+        assert_graph_equal(&graph, &decoded_graph);
+    }
+
+    #[test]
+    fn test_unzip_to_folder() {
+        let graph = Graph::new();
+
+        graph
+            .add_edge(0, 0, 1, [("test prop 1", Prop::map(NO_PROPS))], None)
+            .unwrap();
+        graph
+            .add_edge(
+                1,
+                2,
+                3,
+                [("test prop 1", Prop::map([("key", "value")]))],
+                Some("layer_a"),
+            )
+            .unwrap();
+        graph
+            .add_edge(2, 3, 4, [("test prop 2", "value")], Some("layer_b"))
+            .unwrap();
+        graph
+            .add_edge(3, 1, 4, [("test prop 3", 10.0)], None)
+            .unwrap();
+        graph
+            .add_edge(4, 1, 3, [("test prop 4", true)], None)
+            .unwrap();
+
+        graph
+            .node(1)
+            .unwrap()
+            .add_updates(5, [("test node prop", 5i32)], None)
+            .unwrap();
+
+        let temp_folder = tempfile::TempDir::new().unwrap();
+        let folder = temp_folder.path().join("graph");
+        let graph_folder = GraphFolder::from(&folder);
+
+        graph.encode(&graph_folder).unwrap();
+        assert!(graph_folder.graph_path().unwrap().exists());
+
+        // Zip the folder
+        let mut zip_bytes = Vec::new();
+        let cursor = std::io::Cursor::new(&mut zip_bytes);
+        graph_folder.zip_from_folder(cursor).unwrap();
+
+        // Unzip to a new folder
+        let folder = temp_folder.path().join("unzip");
+        let unzip_folder = GraphFolder::from(&folder);
+        let cursor = std::io::Cursor::new(&zip_bytes);
+        unzip_folder.unzip_to_folder(cursor).unwrap();
+
+        // Verify the extracted folder has the same structure
+        assert!(unzip_folder.graph_path().unwrap().exists());
+        assert!(unzip_folder.meta_path().unwrap().exists());
+
+        // Verify the extracted graph is the same as the original
+        let extracted_graph = Graph::decode(&unzip_folder).unwrap();
+        assert_graph_equal(&graph, &extracted_graph);
+    }
+}
diff --git a/raphtory/src/serialise/incremental.rs b/raphtory/src/serialise/incremental.rs
deleted file mode 100644
index 31208999bd..0000000000
--- a/raphtory/src/serialise/incremental.rs
+++ /dev/null
@@ -1,344 +0,0 @@
-use super::GraphFolder;
-#[cfg(feature = "search")]
-use crate::prelude::IndexMutationOps;
-use crate::{
-    db::{
-        api::{storage::storage::Storage, view::MaterializedGraph},
-        graph::views::deletion_graph::PersistentGraph,
-    },
-    errors::{GraphError, WriteError},
-    prelude::{AdditionOps, Graph, StableDecode},
-    serialise::{
-        serialise::{CacheOps, InternalStableDecode, StableEncode},
-        ProtoGraph,
-    },
-};
-use parking_lot::Mutex;
-use prost::Message;
-use raphtory_api::core::{
-    entities::{
-        properties::prop::{Prop, PropType},
-        GidRef, EID, VID,
-    },
-    storage::{dict_mapper::MaybeNew, timeindex::EventTime},
-};
-use std::{
-    fmt::Debug,
-    io::{Seek, SeekFrom, Write},
-    mem,
-    ops::DerefMut,
-    sync::Arc,
-};
-use tracing::instrument;
-
-#[derive(Debug)]
-pub struct GraphWriter {
-    write_lock: Arc<Mutex<()>>,
-    proto_delta: Mutex<ProtoGraph>,
-    pub(crate) folder: GraphFolder,
-}
-
-fn try_write(folder: &GraphFolder, bytes: &[u8]) -> Result<(), WriteError> {
-    let mut writer = folder.get_appendable_graph_file()?;
-    let pos = writer.seek(SeekFrom::End(0))?;
-    writer
-        .write_all(bytes)
-        .map_err(|write_err| match writer.set_len(pos) {
-            Ok(_) => WriteError::WriteError(write_err),
-            Err(reset_err) => WriteError::FatalWriteError(write_err, reset_err),
-        })
-}
-
-impl GraphWriter {
-    pub fn new(folder: GraphFolder) -> Result<Self, GraphError> {
-        Ok(Self {
-            write_lock: Arc::new(Mutex::new(())),
-            proto_delta: Default::default(),
-            folder,
-        })
-    }
-
-    /// Get an independent writer pointing at the same underlying cache file
-    pub fn fork(&self) -> Self {
-        GraphWriter {
-            write_lock: self.write_lock.clone(),
-            proto_delta: Default::default(),
-            folder: self.folder.clone(),
-        }
-    }
-
-    pub fn write(&self) -> Result<(), GraphError> {
-        let mut proto = mem::take(self.proto_delta.lock().deref_mut());
-        let bytes = proto.encode_to_vec();
-        if !bytes.is_empty() {
-            let _guard = self.write_lock.lock();
-            if let Err(write_err) = try_write(&self.folder, &bytes) {
-                // If the write fails, try to put the updates back
-                let mut new_delta = self.proto_delta.lock();
-                let bytes = new_delta.encode_to_vec();
-                match proto.merge(&*bytes) {
-                    Ok(_) => *new_delta = proto,
-                    Err(decode_err) => {
-                        // This should never happen, it means that the new delta was an invalid Graph
-                        return Err(GraphError::FatalDecodeError {
-                            write_err,
-                            decode_err,
-                        });
-                    }
-                }
-                return Err(write_err.into());
-            }
-            // should we flush the file?
-        }
-        Ok(())
-    }
-
-    #[inline]
-    pub fn resolve_layer(&self, layer: Option<&str>, layer_id: MaybeNew<usize>) {
-        layer_id.if_new(|id| {
-            let layer = layer.unwrap_or("_default");
-            self.proto_delta.lock().new_layer(layer, id)
-        });
-    }
-
-    pub fn resolve_node(&self, vid: MaybeNew<VID>, gid: GidRef) {
-        vid.if_new(|vid| self.proto_delta.lock().new_node(gid, vid, 0));
-    }
-
-    pub fn resolve_node_and_type(
-        &self,
-        node_and_type: MaybeNew<(MaybeNew<VID>, MaybeNew<usize>)>,
-        node_type: &str,
-        gid: GidRef,
-    ) {
-        if let MaybeNew::New((MaybeNew::Existing(node_id), type_id)) = node_and_type {
-            // type assignment changed but node already exists
-            self.proto_delta
-                .lock()
-                .update_node_type(node_id, type_id.inner());
-        }
-        if let (MaybeNew::New(node_id), type_id) = node_and_type.inner() {
-            self.proto_delta
-                .lock()
-                .new_node(gid, node_id, type_id.inner());
-        }
-        if let (_, MaybeNew::New(type_id)) = node_and_type.inner() {
-            self.proto_delta.lock().new_node_type(node_type, type_id);
-        }
-    }
-
-    pub fn resolve_graph_property(
-        &self,
-        prop: &str,
-        prop_id: MaybeNew<usize>,
-        dtype: PropType,
-        is_static: bool,
-    ) {
-        prop_id.if_new(|id| {
-            if is_static {
-                self.proto_delta.lock().new_graph_cprop(prop, id);
-            } else {
-                self.proto_delta.lock().new_graph_tprop(prop, id, &dtype);
-            }
-        });
-    }
-
-    pub fn resolve_node_property(
-        &self,
-        prop: &str,
-        prop_id: MaybeNew<usize>,
-        dtype: &PropType,
-        is_static: bool,
-    ) {
-        prop_id.if_new(|id| {
-            if is_static {
-                self.proto_delta.lock().new_node_cprop(prop, id, dtype);
-            } else {
-                self.proto_delta.lock().new_node_tprop(prop, id, dtype);
-            }
-        });
-    }
-
-    pub fn resolve_edge_property(
-        &self,
-        prop: &str,
-        prop_id: MaybeNew<usize>,
-        dtype: &PropType,
-        is_static: bool,
-    ) {
-        prop_id.if_new(|id| {
-            if is_static {
-                self.proto_delta.lock().new_edge_cprop(prop, id, dtype);
-            } else {
-                self.proto_delta.lock().new_edge_tprop(prop, id, dtype);
-            }
-        });
-    }
-
-    pub fn add_node_update(&self, t: EventTime, v: VID, props: &[(usize, Prop)]) {
-        self.proto_delta
-            .lock()
-            .update_node_tprops(v, t, props.iter().map(|(id, prop)| (*id, prop)))
-    }
-
-    pub fn resolve_edge(&self, eid: MaybeNew<EID>, src: VID, dst: VID) {
-        eid.if_new(|eid| self.proto_delta.lock().new_edge(src, dst, eid));
-    }
-
-    pub fn add_edge_update(&self, t: EventTime, edge: EID, props: &[(usize, Prop)], layer: usize) {
-        self.proto_delta.lock().update_edge_tprops(
-            edge,
-            t,
-            layer,
-            props.iter().map(|(id, prop)| (*id, prop)),
-        )
-    }
-    pub fn add_graph_tprops(&self, t: EventTime, props: &[(usize, Prop)]) {
-        self.proto_delta
-            .lock()
-            .update_graph_tprops(t, props.iter().map(|(id, prop)| (*id, prop)))
-    }
-
-    pub fn add_graph_cprops(&self, props: &[(usize, Prop)]) {
-        self.proto_delta
-            .lock()
-            .update_graph_cprops(props.iter().map(|(id, prop)| (*id, prop)))
-    }
-
-    pub fn add_node_cprops(&self, node: VID, props: &[(usize, Prop)]) {
-        self.proto_delta
-            .lock()
-            .update_node_cprops(node, props.iter().map(|(id, prop)| (*id, prop)))
-    }
-
-    pub fn add_edge_cprops(&self, edge: EID, layer: usize, props: &[(usize, Prop)]) {
-        if !props.is_empty() {
-            self.proto_delta.lock().update_edge_cprops(
-                edge,
-                layer,
-                props.iter().map(|(id, prop)| (*id, prop)),
-            )
-        }
-    }
-
-    pub fn delete_edge(&self, edge: EID, t: EventTime, layer: usize) {
-        self.proto_delta.lock().del_edge(edge, layer, t)
-    }
-}
-
-pub trait InternalCache {
-    /// Initialise the cache by pointing it at a proto file.
-    /// Future updates will be appended to the cache.
-    fn init_cache(&self, path: &GraphFolder) -> Result<(), GraphError>;
-
-    /// Get the cache writer if it is initialised.
-    fn get_cache(&self) -> Option<&GraphWriter>;
-}
-
-impl InternalCache for Storage {
-    fn init_cache(&self, path: &GraphFolder) -> Result<(), GraphError> {
-        self.cache
-            .get_or_try_init(|| GraphWriter::new(path.clone()))?;
-        Ok(())
-    }
-
-    fn get_cache(&self) -> Option<&GraphWriter> {
-        self.cache.get()
-    }
-}
-
-impl InternalCache for Graph {
-    fn init_cache(&self, path: &GraphFolder) -> Result<(), GraphError> {
-        self.inner.init_cache(path)
-    }
-
-    fn get_cache(&self) -> Option<&GraphWriter> {
-        self.inner.get_cache()
-    }
-}
-
-impl InternalCache for PersistentGraph {
-    fn init_cache(&self, path: &GraphFolder) -> Result<(), GraphError> {
-        self.0.init_cache(path)
-    }
-
-    fn get_cache(&self) -> Option<&GraphWriter> {
-        self.0.get_cache()
-    }
-}
-
-impl InternalCache for MaterializedGraph {
-    fn init_cache(&self, path: &GraphFolder) -> Result<(), GraphError> {
-        match self {
-            MaterializedGraph::EventGraph(g) => g.init_cache(path),
-            MaterializedGraph::PersistentGraph(g) => g.init_cache(path),
-        }
-    }
-
-    fn get_cache(&self) -> Option<&GraphWriter> {
-        match self {
-            MaterializedGraph::EventGraph(g) => g.get_cache(),
-            MaterializedGraph::PersistentGraph(g) => g.get_cache(),
-        }
-    }
-}
-
-impl<G: InternalCache + InternalStableDecode + StableEncode + AdditionOps> CacheOps for G {
-    fn cache(&self, path: impl Into<GraphFolder>) -> Result<(), GraphError> {
-        let folder = path.into();
-        self.encode(&folder)?;
-        self.init_cache(&folder)
-    }
-
-    #[instrument(level = "debug", skip(self))]
-    fn write_updates(&self) -> Result<(), GraphError> {
-        let cache = self.get_cache().ok_or(GraphError::CacheNotInnitialised)?;
-        cache.write()?;
-        cache.folder.write_metadata(self)?;
-        #[cfg(feature = "search")]
-        self.persist_index_to_disk(&cache.folder)?;
-        Ok(())
-    }
-
-    fn load_cached(path: impl Into<GraphFolder>) -> Result<Self, GraphError> {
-        let folder = path.into();
-        if folder.is_zip() {
-            return Err(GraphError::ZippedGraphCannotBeCached);
-        }
-        let graph = Self::decode(&folder)?;
-        graph.init_cache(&folder)?;
-        Ok(graph)
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use crate::serialise::{incremental::GraphWriter, GraphFolder};
-    use raphtory_api::core::{
-        entities::{GidRef, VID},
-        storage::dict_mapper::MaybeNew,
-        utils::logging::global_info_logger,
-    };
-    use std::fs::File;
-    use tempfile::TempDir;
-
-    // Tests that changes to the cache graph are not thrown away if cache write fails
-    // and there is a chance to recover from this.
-    #[test]
-    fn test_write_failure() {
-        global_info_logger();
-        let tmp_dir = TempDir::new().unwrap();
-        let folder = GraphFolder::from(tmp_dir.path());
-        let graph_file_path = folder.get_graph_path();
-        let file = File::create(&graph_file_path).unwrap();
-        let mut perms = file.metadata().unwrap().permissions();
-        perms.set_readonly(true);
-        file.set_permissions(perms).unwrap();
-        let cache = GraphWriter::new(folder).unwrap();
-        cache.resolve_node(MaybeNew::New(VID(0)), GidRef::Str("0"));
-        assert_eq!(cache.proto_delta.lock().nodes.len(), 1);
-        let res = cache.write();
-        assert!(res.is_err());
-        assert_eq!(cache.proto_delta.lock().nodes.len(), 1);
-    }
-}
diff --git a/raphtory/src/serialise/metadata.rs b/raphtory/src/serialise/metadata.rs
index 8d5aa6c43d..67cbae6375 100644
--- a/raphtory/src/serialise/metadata.rs
+++ b/raphtory/src/serialise/metadata.rs
@@ -1,20 +1,37 @@
 use crate::{
-    prelude::{GraphViewOps, PropertiesOps},
-    serialise::GraphFolder,
+    db::api::view::internal::GraphView,
+    prelude::GraphViewOps,
+    serialise::{GraphFolder, GraphPaths},
 };
-use raphtory_api::core::{entities::properties::prop::Prop, storage::arc_str::ArcStr};
+use raphtory_api::GraphType;
 use serde::{Deserialize, Serialize};
 
 #[derive(PartialEq, Serialize, Deserialize, Debug)]
 pub struct GraphMetadata {
     pub node_count: usize,
     pub edge_count: usize,
-    pub metadata: Vec<(ArcStr, Prop)>,
+    pub graph_type: GraphType,
+    pub is_diskgraph: bool,
+}
+
+impl GraphMetadata {
+    pub fn from_graph<G: GraphView>(graph: G) -> Self {
+        let node_count = graph.count_nodes();
+        let edge_count = graph.count_edges();
+        let graph_type = graph.graph_type();
+        let is_diskgraph = graph.disk_storage_path().is_some();
+        Self {
+            node_count,
+            edge_count,
+            graph_type,
+            is_diskgraph,
+        }
+    }
 }
 
 pub fn assert_metadata_correct<'graph>(folder: &GraphFolder, graph: &impl GraphViewOps<'graph>) {
     let metadata = folder.read_metadata().unwrap();
     assert_eq!(metadata.node_count, graph.count_nodes());
     assert_eq!(metadata.edge_count, graph.count_edges());
-    assert_eq!(metadata.metadata, graph.properties().as_vec());
+    assert_eq!(metadata.graph_type, graph.graph_type());
 }
diff --git a/raphtory/src/serialise/mod.rs b/raphtory/src/serialise/mod.rs
index 73e5198af5..ec33629745 100644
--- a/raphtory/src/serialise/mod.rs
+++ b/raphtory/src/serialise/mod.rs
@@ -1,351 +1,14 @@
-use memmap2::Mmap;
-use zip::{write::FileOptions, ZipArchive, ZipWriter};
-
-pub(crate) mod incremental;
+mod graph_folder;
 pub mod metadata;
-pub(crate) mod parquet;
-mod proto_ext;
-mod serialise;
-
-mod proto {
-    include!(concat!(env!("OUT_DIR"), "/serialise.rs"));
-}
-#[cfg(feature = "search")]
-use crate::prelude::IndexMutationOps;
-use crate::{
-    db::api::view::MaterializedGraph,
-    errors::GraphError,
-    prelude::{GraphViewOps, PropertiesOps},
-    serialise::metadata::GraphMetadata,
-};
-pub use proto::Graph as ProtoGraph;
-#[cfg(feature = "storage")]
-use raphtory_storage::disk::DiskGraphStorage;
-pub use serialise::{CacheOps, InternalStableDecode, StableDecode, StableEncode};
-use std::{
-    fs::{self, File, OpenOptions},
-    io::{self, BufReader, ErrorKind, Read, Seek, Write},
-    path::{Path, PathBuf},
-};
-use tracing::info;
-
-const GRAPH_FILE_NAME: &str = "graph";
-const META_FILE_NAME: &str = ".raph";
-const INDEX_PATH: &str = "index";
-const VECTORS_PATH: &str = "vectors";
-
-#[derive(Clone, Debug, PartialOrd, PartialEq, Ord, Eq)]
-pub struct GraphFolder {
-    pub root_folder: PathBuf,
-    pub(crate) write_as_zip_format: bool,
-}
-
-pub enum GraphReader {
-    Zip(Vec<u8>),
-    Folder(Mmap),
-}
-
-impl AsRef<[u8]> for GraphReader {
-    fn as_ref(&self) -> &[u8] {
-        match self {
-            Self::Zip(bytes) => bytes.as_ref(),
-            Self::Folder(mmap) => mmap.as_ref(),
-        }
-    }
-}
-
-impl GraphFolder {
-    pub fn new_as_zip(path: impl AsRef<Path>) -> Self {
-        let folder: GraphFolder = path.into();
-        Self {
-            write_as_zip_format: true,
-            ..folder
-        }
-    }
-
-    // TODO: make it private again once we stop using it from the graphql crate
-    pub fn get_graph_path(&self) -> PathBuf {
-        self.root_folder.join(GRAPH_FILE_NAME)
-    }
-
-    pub fn get_meta_path(&self) -> PathBuf {
-        self.root_folder.join(META_FILE_NAME)
-    }
-
-    // TODO: make private once possible
-    pub fn get_vectors_path(&self) -> PathBuf {
-        self.root_folder.join(VECTORS_PATH)
-    }
-
-    pub fn get_index_path(&self) -> PathBuf {
-        self.root_folder.join(INDEX_PATH)
-    }
-
-    // TODO: make private once possible
-    pub fn get_base_path(&self) -> &Path {
-        &self.root_folder
-    }
-
-    pub fn is_zip(&self) -> bool {
-        self.root_folder.is_file()
-    }
-
-    pub fn read_graph(&self) -> Result<GraphReader, io::Error> {
-        if self.is_zip() {
-            let file = File::open(&self.root_folder)?;
-            let mut archive = ZipArchive::new(file)?;
-            let mut entry = archive.by_name(GRAPH_FILE_NAME)?;
-            let mut buf = vec![];
-            entry.read_to_end(&mut buf)?;
-            Ok(GraphReader::Zip(buf))
-        } else {
-            let file = File::open(self.get_graph_path())?;
-            let buf = unsafe { memmap2::MmapOptions::new().map(&file)? };
-            Ok(GraphReader::Folder(buf))
-        }
-    }
-
-    pub fn write_graph(&self, graph: &impl StableEncode) -> Result<(), GraphError> {
-        self.write_graph_data(graph)?;
-        self.write_metadata(graph)?;
-
-        #[cfg(feature = "search")]
-        self.write_index(graph)?;
-
-        Ok(())
-    }
 
-    #[cfg(feature = "search")]
-    fn write_index(&self, graph: &impl StableEncode) -> Result<(), GraphError> {
-        if self.write_as_zip_format {
-            graph.persist_index_to_disk_zip(&self)
-        } else {
-            graph.persist_index_to_disk(&self)
-        }
-    }
+pub mod parquet;
 
-    fn write_graph_data(&self, graph: &impl StableEncode) -> Result<(), io::Error> {
-        let bytes = graph.encode_to_vec();
-        if self.write_as_zip_format {
-            let file = File::create_new(&self.root_folder)?;
-            let mut zip = ZipWriter::new(file);
-            zip.start_file::<_, ()>(GRAPH_FILE_NAME, FileOptions::default())?;
-            zip.write_all(&bytes)
-        } else {
-            self.ensure_clean_root_dir()?;
-            let mut file = File::create_new(self.get_graph_path())?;
-            file.write_all(&bytes)
-        }
-    }
-
-    pub fn read_metadata(&self) -> Result<GraphMetadata, GraphError> {
-        match self.try_read_metadata() {
-            Ok(data) => Ok(data),
-            Err(e) => {
-                match e.kind() {
-                    // In the case that the file is not found or invalid, try creating it then re-reading
-                    ErrorKind::NotFound | ErrorKind::InvalidData | ErrorKind::UnexpectedEof => {
-                        info!(
-                            "Metadata file does not exist or is invalid. Attempting to recreate..."
-                        );
-                        let graph: MaterializedGraph = if self.is_disk_graph() {
-                            #[cfg(not(feature = "storage"))]
-                            return Err(GraphError::DiskGraphNotFound);
-                            #[cfg(feature = "storage")]
-                            {
-                                use crate::prelude::IntoGraph;
-
-                                MaterializedGraph::from(
-                                    DiskGraphStorage::load_from_dir(self.get_graph_path())?
-                                        .into_graph(),
-                                )
-                            }
-                        } else {
-                            MaterializedGraph::decode(self)?
-                        };
-                        self.write_metadata(&graph)?;
-                        Ok(self.try_read_metadata()?)
-                    }
-                    _ => Err(e.into()),
-                }
-            }
-        }
-    }
-
-    pub fn try_read_metadata(&self) -> Result<GraphMetadata, io::Error> {
-        if self.root_folder.is_file() {
-            let file = File::open(&self.root_folder)?;
-            let mut archive = ZipArchive::new(file)?;
-            let zip_file = archive.by_name(META_FILE_NAME)?;
-            let reader = BufReader::new(zip_file);
-            let metadata = serde_json::from_reader(reader)?;
-            Ok(metadata)
-        } else {
-            let file = File::open(self.get_meta_path())?;
-            let reader = BufReader::new(file);
-            let metadata = serde_json::from_reader(reader)?;
-            Ok(metadata)
-        }
-    }
-
-    fn write_metadata<'graph>(&self, graph: &impl GraphViewOps<'graph>) -> Result<(), GraphError> {
-        let node_count = graph.count_nodes();
-        let edge_count = graph.count_edges();
-        let properties = graph.metadata();
-        let metadata = GraphMetadata {
-            node_count,
-            edge_count,
-            metadata: properties.as_vec(),
-        };
-        if self.write_as_zip_format {
-            let file = File::options()
-                .read(true)
-                .write(true)
-                .open(&self.root_folder)?;
-            let mut zip = ZipWriter::new_append(file)?;
-            zip.start_file::<_, ()>(META_FILE_NAME, FileOptions::default())?;
-            Ok(serde_json::to_writer(zip, &metadata)?)
-        } else {
-            let path = self.get_meta_path();
-            let file = File::create(path.clone())?;
-            Ok(serde_json::to_writer(file, &metadata)?)
-        }
-    }
-
-    pub(crate) fn get_appendable_graph_file(&self) -> Result<File, io::Error> {
-        let path = self.get_graph_path();
-        Ok(OpenOptions::new().append(true).open(path)?)
-    }
-
-    fn ensure_clean_root_dir(&self) -> Result<(), GraphError> {
-        if self.root_folder.exists() {
-            let non_empty = self.root_folder.read_dir()?.next().is_some();
-            if non_empty {
-                return Err(GraphError::NonEmptyGraphFolder(self.root_folder.clone()));
-            }
-        } else {
-            fs::create_dir(&self.root_folder)?
-        }
-        File::create_new(self.root_folder.join(META_FILE_NAME))?;
-        Ok(())
-    }
-
-    fn is_disk_graph(&self) -> bool {
-        let path = self.get_graph_path();
-        path.is_dir()
-    }
-
-    pub fn create_zip<W: Write + Seek>(&self, mut writer: W) -> Result<(), GraphError> {
-        let mut buffer = Vec::new();
-        if self.is_zip() {
-            let mut reader = File::open(&self.root_folder)?;
-            reader.read_to_end(&mut buffer)?;
-            writer.write_all(&buffer)?;
-        } else {
-            let mut zip = ZipWriter::new(writer);
-            let graph_file = self.get_graph_path();
-            {
-                // scope for file
-                let mut reader = File::open(&graph_file)?;
-                reader.read_to_end(&mut buffer)?;
-                zip.start_file::<_, ()>(GRAPH_FILE_NAME, FileOptions::default())?;
-                zip.write_all(&buffer)?;
-            }
-            {
-                // scope for file
-                buffer.clear();
-                let mut reader = File::open(self.get_meta_path())?;
-                reader.read_to_end(&mut buffer)?;
-                zip.start_file::<_, ()>(META_FILE_NAME, FileOptions::default())?;
-                zip.write_all(&buffer)?;
-            }
-        }
-        Ok(())
-    }
-}
-
-impl<P: AsRef<Path>> From<P> for GraphFolder {
-    fn from(value: P) -> Self {
-        let path: &Path = value.as_ref();
-        Self {
-            root_folder: path.to_path_buf(),
-            write_as_zip_format: false,
-        }
-    }
-}
-
-impl From<&GraphFolder> for GraphFolder {
-    fn from(value: &GraphFolder) -> Self {
-        value.clone()
-    }
-}
-
-// this mod focuses on the zip format, as the folder format is
-// the default and is largely exercised in other places
-#[cfg(test)]
-mod zip_tests {
-    use super::StableEncode;
-    use crate::{
-        prelude::{AdditionOps, CacheOps, Graph, NO_PROPS},
-        serialise::{metadata::GraphMetadata, GraphFolder},
-    };
-    use raphtory_api::core::utils::logging::global_info_logger;
-
-    #[test]
-    fn test_load_cached_from_zip() {
-        let graph = Graph::new();
-        graph.add_node(0, 0, NO_PROPS, None).unwrap();
-        let tmp_dir = tempfile::TempDir::new().unwrap();
-        let zip_path = tmp_dir.path().join("graph.zip");
-        graph.encode(GraphFolder::new_as_zip(&zip_path)).unwrap();
-        let result = Graph::load_cached(&zip_path);
-        assert!(result.is_err());
-    }
-
-    #[test]
-    fn test_read_metadata_from_noninitialized_zip() {
-        global_info_logger();
-
-        let graph = Graph::new();
-        graph.add_node(0, 0, NO_PROPS, None).unwrap();
-
-        let tmp_dir = tempfile::TempDir::new().unwrap();
-        let zip_path = tmp_dir.path().join("graph.zip");
-        let folder = GraphFolder::new_as_zip(&zip_path);
-        folder.write_graph_data(&graph).unwrap();
-
-        let err = folder.try_read_metadata();
-        assert!(err.is_err());
+#[cfg(feature = "proto")]
+pub mod proto;
+mod serialise;
 
-        let result = folder.read_metadata().unwrap();
-        assert_eq!(
-            result,
-            GraphMetadata {
-                node_count: 1,
-                edge_count: 0,
-                metadata: vec![]
-            }
-        );
-    }
+pub use graph_folder::*;
+pub use serialise::{StableDecode, StableEncode};
 
-    #[test]
-    fn test_read_metadata_from_noninitialized_folder() {
-        global_info_logger();
-        let graph = Graph::new();
-        graph.add_node(0, 0, NO_PROPS, None).unwrap();
-        let temp_folder = tempfile::TempDir::new().unwrap();
-        let folder = GraphFolder::from(temp_folder.path());
-        folder.write_graph_data(&graph).unwrap();
-        let err = folder.try_read_metadata();
-        assert!(err.is_err());
-        let result = folder.read_metadata().unwrap();
-        assert_eq!(
-            result,
-            GraphMetadata {
-                node_count: 1,
-                edge_count: 0,
-                metadata: vec![]
-            }
-        );
-    }
-}
+#[cfg(feature = "proto")]
+pub use proto::proto_generated::Graph as ProtoGraph;
diff --git a/raphtory/src/serialise/parquet/edges.rs b/raphtory/src/serialise/parquet/edges.rs
index 20b8a82aad..dc58a8390f 100644
--- a/raphtory/src/serialise/parquet/edges.rs
+++ b/raphtory/src/serialise/parquet/edges.rs
@@ -5,10 +5,7 @@ use crate::{
 };
 use arrow::datatypes::{DataType, Field};
 use model::ParquetCEdge;
-use raphtory_api::{
-    core::{entities::EID, storage::timeindex::TimeIndexOps},
-    iter::IntoDynBoxed,
-};
+use raphtory_api::{core::storage::timeindex::TimeIndexOps, iter::IntoDynBoxed};
 use raphtory_storage::{
     core_ops::CoreGraphOps,
     graph::{edges::edge_storage_ops::EdgeStorageOps, graph::GraphStorage},
@@ -19,18 +16,23 @@ pub(crate) fn encode_edge_tprop(
     g: &GraphStorage,
     path: impl AsRef<Path>,
 ) -> Result<(), GraphError> {
-    run_encode(
+    run_encode_indexed(
         g,
         g.edge_meta().temporal_prop_mapper(),
-        g.unfiltered_num_edges(),
+        g.edges().segmented_par_iter().unwrap_or_else(|| {
+            panic!("Internal Error: segmented_par_iter cannot be called from unlocked GraphStorage")
+        }),
         path,
         EDGES_T_PATH,
-        |id_type| {
+        |_| {
             vec![
                 Field::new(TIME_COL, DataType::Int64, false),
-                Field::new(SRC_COL, id_type.clone(), false),
-                Field::new(DST_COL, id_type.clone(), false),
+                Field::new(SECONDARY_INDEX_COL, DataType::UInt64, true),
+                Field::new(SRC_COL_ID, DataType::UInt64, false),
+                Field::new(DST_COL_ID, DataType::UInt64, false),
+                Field::new(EDGE_COL_ID, DataType::UInt64, false),
                 Field::new(LAYER_COL, DataType::Utf8, true),
+                Field::new(LAYER_ID_COL, DataType::UInt64, true),
             ]
         },
         |edges, g, decoder, writer| {
@@ -38,7 +40,6 @@ pub(crate) fn encode_edge_tprop(
 
             for edge_rows in edges
                 .into_iter()
-                .map(EID)
                 .flat_map(|eid| {
                     let edge_ref = g.core_edge(eid).out_ref();
                     EdgeView::new(g, edge_ref).explode()
@@ -63,18 +64,23 @@ pub(crate) fn encode_edge_deletions(
     g: &GraphStorage,
     path: impl AsRef<Path>,
 ) -> Result<(), GraphError> {
-    run_encode(
+    run_encode_indexed(
         g,
         g.edge_meta().temporal_prop_mapper(),
-        g.unfiltered_num_edges(),
+        g.edges().segmented_par_iter().unwrap_or_else(|| {
+            panic!("Internal Error: segmented_par_iter cannot be called from unlocked GraphStorage")
+        }),
         path,
         EDGES_D_PATH,
-        |id_type| {
+        |_| {
             vec![
                 Field::new(TIME_COL, DataType::Int64, false),
-                Field::new(SRC_COL, id_type.clone(), false),
-                Field::new(DST_COL, id_type.clone(), false),
+                Field::new(SECONDARY_INDEX_COL, DataType::UInt64, true),
+                Field::new(SRC_COL_ID, DataType::UInt64, false),
+                Field::new(DST_COL_ID, DataType::UInt64, false),
+                Field::new(EDGE_COL_ID, DataType::UInt64, false),
                 Field::new(LAYER_COL, DataType::Utf8, true),
+                Field::new(LAYER_ID_COL, DataType::UInt64, true),
             ]
         },
         |edges, g, decoder, writer| {
@@ -90,9 +96,8 @@ pub(crate) fn encode_edge_deletions(
 
             for edge_rows in edges
                 .into_iter()
-                .map(EID)
                 .flat_map(|eid| {
-                    (0..g.unfiltered_num_layers()).flat_map(move |layer_id| {
+                    g.unfiltered_layer_ids().flat_map(move |layer_id| {
                         let edge = g_edges.edge(eid);
                         let edge_ref = edge.out_ref();
                         GenLockedIter::from(edge, |edge| {
@@ -100,7 +105,8 @@ pub(crate) fn encode_edge_deletions(
                         })
                         .map(move |deletions| ParquetDelEdge {
                             del: deletions,
-                            layer: &layers[layer_id],
+                            layer: &layers[layer_id.0 - 1],
+                            layer_id,
                             edge: EdgeView::new(g, edge_ref),
                         })
                     })
@@ -124,29 +130,36 @@ pub(crate) fn encode_edge_cprop(
     g: &GraphStorage,
     path: impl AsRef<Path>,
 ) -> Result<(), GraphError> {
-    run_encode(
+    run_encode_indexed(
         g,
         g.edge_meta().metadata_mapper(),
-        g.unfiltered_num_edges(),
+        g.edges().segmented_par_iter().unwrap_or_else(|| {
+            panic!("Internal Error: segmented_par_iter cannot be called from unlocked GraphStorage")
+        }),
         path,
         EDGES_C_PATH,
-        |id_type| {
+        |_| {
             vec![
-                Field::new(SRC_COL, id_type.clone(), false),
-                Field::new(DST_COL, id_type.clone(), false),
+                Field::new(SRC_COL_ID, DataType::UInt64, false),
+                Field::new(DST_COL_ID, DataType::UInt64, false),
+                Field::new(EDGE_COL_ID, DataType::UInt64, false),
                 Field::new(LAYER_COL, DataType::Utf8, true),
             ]
         },
         |edges, g, decoder, writer| {
-            let row_group_size = 100_000.min(edges.len());
-            let layers = 0..g.unfiltered_num_layers();
+            let row_group_size = 100_000;
 
             for edge_rows in edges
                 .into_iter()
-                .map(EID)
                 .flat_map(|eid| {
                     let edge_ref = g.core_edge(eid).out_ref();
-                    layers.clone().map(move |l_id| edge_ref.at_layer(l_id))
+                    let edges_in_layers = EdgeView::new(g, edge_ref)
+                        .explode_layers()
+                        .into_iter()
+                        .map(|e| e.edge)
+                        .collect_vec();
+
+                    edges_in_layers.into_iter()
                 })
                 .map(|edge| ParquetCEdge(EdgeView::new(g, edge)))
                 .chunks(row_group_size)
diff --git a/raphtory/src/serialise/parquet/graph.rs b/raphtory/src/serialise/parquet/graph.rs
index c089eb4065..e5349bdd30 100644
--- a/raphtory/src/serialise/parquet/graph.rs
+++ b/raphtory/src/serialise/parquet/graph.rs
@@ -2,17 +2,18 @@ use crate::{
     errors::GraphError,
     prelude::{GraphViewOps, Prop, PropertiesOps},
     serialise::parquet::{
-        model::ParquetProp, run_encode, EVENT_GRAPH_TYPE, GRAPH_C_PATH, GRAPH_TYPE, GRAPH_T_PATH,
-        PERSISTENT_GRAPH_TYPE, TIME_COL,
+        run_encode, EVENT_GRAPH_TYPE, GRAPH_C_PATH, GRAPH_TYPE, GRAPH_T_PATH,
+        PERSISTENT_GRAPH_TYPE, SECONDARY_INDEX_COL, TIME_COL,
     },
 };
 use arrow::datatypes::{DataType, Field};
 use itertools::Itertools;
-use parquet::format::KeyValue;
+use parquet::file::metadata::KeyValue;
 use raphtory_api::{
-    core::storage::{arc_str::ArcStr, timeindex::AsTime},
+    core::{entities::properties::prop::SerdeArrowProp, storage::arc_str::ArcStr},
     GraphType,
 };
+use raphtory_core::storage::timeindex::EventTime;
 use raphtory_storage::graph::graph::GraphStorage;
 use serde::{ser::SerializeMap, Serialize};
 use std::{collections::HashMap, path::Path};
@@ -20,48 +21,49 @@ use std::{collections::HashMap, path::Path};
 pub fn encode_graph_tprop(g: &GraphStorage, path: impl AsRef<Path>) -> Result<(), GraphError> {
     run_encode(
         g,
-        g.graph_meta().temporal_mapper(),
+        g.graph_props_meta().temporal_prop_mapper(),
         1,
         path,
         GRAPH_T_PATH,
-        |_| vec![Field::new(TIME_COL, DataType::Int64, false)],
+        |_| {
+            vec![
+                Field::new(TIME_COL, DataType::Int64, false),
+                Field::new(SECONDARY_INDEX_COL, DataType::UInt64, true),
+            ]
+        },
         |_, g, decoder, writer| {
-            let merged_props = g
-                .properties()
-                .temporal()
+            // Collect into owned props here to avoid lifetime issues on prop_view.
+            // Ideally we want to be returning refs to the props but this
+            // is not possible with the current API.
+            let collect_props = g.properties().temporal().iter().collect::<Vec<_>>();
+
+            // Each prop key can have multiple values over time.
+            // Flatten into (time, key, value) tuples to group by time.
+            let merged_props = collect_props
+                .iter()
+                .map(|(prop_key, prop_view)| {
+                    // Collect all the props for a given prop key
+                    prop_view
+                        .iter_indexed()
+                        .map(move |(time, prop_value)| (time, prop_key.clone(), prop_value))
+                })
+                .kmerge_by(|(left_t, _, _), (right_t, _, _)| left_t <= right_t);
+
+            // Group property (key, value) tuples by time to create rows.
+            let rows: Vec<Row> = merged_props
+                .chunk_by(|(t, _, _)| *t)
                 .into_iter()
-                .map(|(k, view)| {
-                    view.into_iter()
-                        .map(move |(t, prop)| (k.clone(), t.t(), prop))
+                .map(|(timestamp, group)| {
+                    let row = group
+                        .map(|(_, prop_key, prop_value)| (prop_key, prop_value))
+                        .collect();
+
+                    Row { t: timestamp, row }
                 })
-                .kmerge_by(|(_, t1, _), (_, t2, _)| t1 < t2);
-
-            let mut row = HashMap::<ArcStr, Prop>::new();
-            let mut rows = vec![];
-            let mut last_t: Option<i64> = None;
-            for (key, t1, prop) in merged_props {
-                if let Some(last_t) = last_t {
-                    if last_t != t1 {
-                        let mut old = HashMap::<ArcStr, Prop>::new();
-                        std::mem::swap(&mut row, &mut old);
-                        rows.push(Row {
-                            t: last_t,
-                            row: old,
-                        });
-                    }
-                }
-
-                row.insert(key, prop);
-                last_t = Some(t1);
-            }
-            if !row.is_empty() {
-                rows.push(Row {
-                    t: last_t.unwrap(),
-                    row,
-                });
-            }
+                .collect();
 
             decoder.serialize(&rows)?;
+
             if let Some(rb) = decoder.flush()? {
                 writer.write(&rb)?;
                 writer.flush()?;
@@ -74,7 +76,7 @@ pub fn encode_graph_tprop(g: &GraphStorage, path: impl AsRef<Path>) -> Result<()
 
 #[derive(Debug)]
 struct Row {
-    t: i64,
+    t: EventTime,
     row: HashMap<ArcStr, Prop>,
 }
 
@@ -84,10 +86,14 @@ impl Serialize for Row {
         S: serde::Serializer,
     {
         let mut state = serializer.serialize_map(Some(self.row.len()))?;
+
         for (k, v) in self.row.iter() {
-            state.serialize_entry(k, &ParquetProp(v))?;
+            state.serialize_entry(k, &SerdeArrowProp(v))?;
         }
-        state.serialize_entry(TIME_COL, &self.t)?;
+
+        state.serialize_entry(TIME_COL, &self.t.0)?;
+        state.serialize_entry(SECONDARY_INDEX_COL, &self.t.1)?;
+
         state.end()
     }
 }
@@ -99,16 +105,18 @@ pub fn encode_graph_cprop(
 ) -> Result<(), GraphError> {
     run_encode(
         g,
-        g.graph_meta().metadata_mapper(),
+        g.graph_props_meta().metadata_mapper(),
         1,
         path,
         GRAPH_C_PATH,
         |_| vec![Field::new(TIME_COL, DataType::Int64, true)],
         |_, g, decoder, writer| {
             let row = g.metadata().as_map();
+            let time = EventTime::new(0, 0); // const props don't have time
+            let rows = vec![Row { t: time, row }];
 
-            let rows = vec![Row { t: 0, row }];
             decoder.serialize(&rows)?;
+
             if let Some(rb) = decoder.flush()? {
                 writer.write(&rb)?;
                 writer.flush()?;
diff --git a/raphtory/src/serialise/parquet/mod.rs b/raphtory/src/serialise/parquet/mod.rs
index b0a1a426d1..c0248d9aeb 100644
--- a/raphtory/src/serialise/parquet/mod.rs
+++ b/raphtory/src/serialise/parquet/mod.rs
@@ -4,16 +4,24 @@ use crate::{
         graph::views::deletion_graph::PersistentGraph,
     },
     errors::GraphError,
-    io::parquet_loaders::{
-        load_edge_deletions_from_parquet, load_edge_metadata_from_parquet, load_edges_from_parquet,
-        load_graph_props_from_parquet, load_node_metadata_from_parquet, load_nodes_from_parquet,
+    io::{
+        arrow::df_loaders::edges::ColumnNames,
+        parquet_loaders::{
+            get_parquet_file_paths, load_edge_deletions_from_parquet,
+            load_edge_metadata_from_parquet, load_edges_from_parquet,
+            load_graph_props_from_parquet, load_node_metadata_from_parquet,
+            load_nodes_from_parquet, process_parquet_file_to_df,
+        },
     },
     prelude::*,
-    serialise::parquet::{
-        edges::encode_edge_deletions,
-        graph::{encode_graph_cprop, encode_graph_tprop},
-        model::get_id_type,
-        nodes::{encode_nodes_cprop, encode_nodes_tprop},
+    serialise::{
+        parquet::{
+            edges::encode_edge_deletions,
+            graph::{encode_graph_cprop, encode_graph_tprop},
+            model::get_id_type,
+            nodes::{encode_nodes_cprop, encode_nodes_tprop},
+        },
+        GraphPaths,
     },
 };
 use arrow::datatypes::{DataType, Field, Schema, SchemaRef};
@@ -28,7 +36,10 @@ use parquet::{
 };
 use raphtory_api::{
     core::entities::{
-        properties::{meta::PropMapper, prop::arrow_dtype_from_prop_type},
+        properties::{
+            meta::PropMapper,
+            prop::{arrow_dtype_from_prop_type, prop_col::lift_property_col},
+        },
         GidType,
     },
     GraphType,
@@ -37,10 +48,14 @@ use raphtory_storage::{core_ops::CoreGraphOps, graph::graph::GraphStorage};
 use rayon::prelude::*;
 use std::{
     fs::File,
+    io::{Read, Seek, Write},
     ops::Range,
     path::{Path, PathBuf},
     sync::Arc,
 };
+use storage::Config;
+use walkdir::WalkDir;
+use zip::{write::FileOptions, ZipArchive, ZipWriter};
 
 mod edges;
 mod model;
@@ -49,50 +64,151 @@ mod nodes;
 mod graph;
 
 pub trait ParquetEncoder {
+    /// Encode the graph as parquet data to the zip writer
+    /// (note the writer is still open for appending more data after calling this function)
+    ///
+    /// The graph data will be written at `prefix` inside the zip.
+    fn encode_parquet_to_zip<W: Write + Seek, P: AsRef<Path>>(
+        &self,
+        mut zip_writer: &mut ZipWriter<W>,
+        prefix: P,
+    ) -> Result<(), GraphError> {
+        let prefix = prefix.as_ref();
+        // Encode to a tmp dir using parquet, then zip it to the writer
+        let temp_dir = tempfile::tempdir()?;
+        self.encode_parquet(&temp_dir)?;
+
+        // Walk through the directory and add files and directories to the zip.
+        // Files and directories are stored in the archive under the GRAPH_PATH directory.
+        for entry in WalkDir::new(temp_dir.path())
+            .into_iter()
+            .filter_map(Result::ok)
+        {
+            let path = entry.path();
+
+            let relative_path = path.strip_prefix(temp_dir.path()).map_err(|e| {
+                GraphError::IOErrorMsg(format!("Failed to strip prefix from path: {}", e))
+            })?;
+
+            // Attach GRAPH_PATH as a prefix to the relative path
+            let zip_entry_name = prefix.join(relative_path).to_string_lossy().into_owned();
+
+            if path.is_file() {
+                zip_writer.start_file::<_, ()>(zip_entry_name, FileOptions::<()>::default())?;
+
+                let mut file = std::fs::File::open(path)?;
+                std::io::copy(&mut file, &mut zip_writer)?;
+            } else if path.is_dir() {
+                // Add empty directories to the zip
+                zip_writer.add_directory::<_, ()>(zip_entry_name, FileOptions::<()>::default())?;
+            }
+        }
+        Ok(())
+    }
+
     fn encode_parquet(&self, path: impl AsRef<Path>) -> Result<(), GraphError>;
 }
 
-pub trait ParquetDecoder {
-    fn decode_parquet(path: impl AsRef<Path>) -> Result<Self, GraphError>
-    where
-        Self: Sized;
+pub trait ParquetDecoder: Sized {
+    fn decode_parquet_from_bytes<P: AsRef<Path>>(
+        bytes: &[u8],
+        path_for_decoded_graph: Option<&Path>,
+        prefix: P,
+        config: Config,
+    ) -> Result<Self, GraphError> {
+        // Read directly from an in-memory cursor
+        let mut reader = ZipArchive::new(std::io::Cursor::new(bytes))?;
+        Self::decode_parquet_from_zip(&mut reader, path_for_decoded_graph, prefix, config)
+    }
+
+    fn decode_parquet_from_zip<R: Read + Seek, P: AsRef<Path>>(
+        zip: &mut ZipArchive<R>,
+        path_for_decoded_graph: Option<&Path>,
+        prefix: P,
+        config: Config,
+    ) -> Result<Self, GraphError> {
+        let prefix = prefix.as_ref();
+        // Unzip to a temp dir and decode parquet from there
+        let temp_dir = tempfile::tempdir()?;
+
+        for i in 0..zip.len() {
+            let mut file = zip.by_index(i)?;
+            let zip_entry_name = match file.enclosed_name() {
+                Some(name) => name,
+                None => continue,
+            };
+
+            if let Ok(relative_path) = zip_entry_name.strip_prefix(prefix) {
+                let out_path = temp_dir.path().join(relative_path);
+                if file.is_dir() {
+                    std::fs::create_dir_all(&out_path)?;
+                } else {
+                    // Create any parent directories
+                    if let Some(parent) = out_path.parent() {
+                        std::fs::create_dir_all(parent)?;
+                    }
+                    let mut out_file = std::fs::File::create(&out_path)?;
+                    std::io::copy(&mut file, &mut out_file)?;
+                }
+            }
+        }
+        Self::decode_parquet(temp_dir.path(), path_for_decoded_graph, config)
+    }
+
+    fn decode_parquet(
+        path: impl AsRef<Path>,
+        path_for_decoded_graph: Option<&Path>,
+        config: Config,
+    ) -> Result<Self, GraphError>;
 }
 
-const NODE_ID: &str = "rap_node_id";
+const NODE_ID_COL: &str = "rap_node_id";
+const NODE_VID_COL: &str = "rap_node_vid";
 const TYPE_COL: &str = "rap_node_type";
+const TYPE_ID_COL: &str = "rap_node_type_id";
 const TIME_COL: &str = "rap_time";
-const SRC_COL: &str = "rap_src";
-const DST_COL: &str = "rap_dst";
+const SECONDARY_INDEX_COL: &str = "rap_secondary_index";
+const SRC_COL_ID: &str = "rap_src_id";
+const DST_COL_ID: &str = "rap_dst_id";
+const EDGE_COL_ID: &str = "rap_edge_id";
 const LAYER_COL: &str = "rap_layer";
+const LAYER_ID_COL: &str = "rap_layer_id";
 const EDGES_T_PATH: &str = "edges_t";
 const EDGES_D_PATH: &str = "edges_d"; // deletions
 const EDGES_C_PATH: &str = "edges_c";
 const NODES_T_PATH: &str = "nodes_t";
 const NODES_C_PATH: &str = "nodes_c";
-
 const GRAPH_T_PATH: &str = "graph_t";
 const GRAPH_C_PATH: &str = "graph_c";
-
 const GRAPH_TYPE: &str = "graph_type";
-
 const EVENT_GRAPH_TYPE: &str = "rap_event_graph";
-
 const PERSISTENT_GRAPH_TYPE: &str = "rap_persistent_graph";
 
 impl ParquetEncoder for Graph {
     fn encode_parquet(&self, path: impl AsRef<Path>) -> Result<(), GraphError> {
-        let gs = self.core_graph().clone();
+        let gs = self.core_graph().lock();
         encode_graph_storage(&gs, path, GraphType::EventGraph)
     }
 }
 
 impl ParquetEncoder for PersistentGraph {
     fn encode_parquet(&self, path: impl AsRef<Path>) -> Result<(), GraphError> {
-        let gs = self.core_graph().clone();
+        let gs = self.core_graph().lock();
         encode_graph_storage(&gs, path, GraphType::PersistentGraph)
     }
 }
 
+impl ParquetEncoder for MaterializedGraph {
+    fn encode_parquet(&self, path: impl AsRef<Path>) -> Result<(), GraphError> {
+        match self {
+            MaterializedGraph::EventGraph(graph) => graph.encode_parquet(path),
+            MaterializedGraph::PersistentGraph(persistent_graph) => {
+                persistent_graph.encode_parquet(path)
+            }
+        }
+    }
+}
+
 fn encode_graph_storage(
     g: &GraphStorage,
     path: impl AsRef<Path>,
@@ -153,6 +269,41 @@ pub(crate) fn run_encode(
     Ok(())
 }
 
+pub(crate) fn run_encode_indexed<Index, II: Iterator<Item = Index>>(
+    g: &GraphStorage,
+    meta: &PropMapper,
+    items: impl ParallelIterator<Item = (usize, II)>,
+    path: impl AsRef<Path>,
+    suffix: &str,
+    default_fields_fn: impl Fn(&DataType) -> Vec<Field>,
+    encode_fn: impl Fn(II, &GraphStorage, &mut Decoder, &mut ArrowWriter<File>) -> Result<(), GraphError>
+        + Sync,
+) -> Result<(), GraphError> {
+    let schema = derive_schema(meta, g.id_type(), default_fields_fn)?;
+    let root_dir = path.as_ref().join(suffix);
+    std::fs::create_dir_all(&root_dir)?;
+
+    let num_digits = 8;
+
+    items.try_for_each(|(chunk, items)| {
+        let props = WriterProperties::builder()
+            .set_compression(Compression::SNAPPY)
+            .build();
+
+        let node_file = File::create(root_dir.join(format!("{chunk:0num_digits$}.parquet")))?;
+        let mut writer = ArrowWriter::try_new(node_file, schema.clone(), Some(props))?;
+
+        let mut decoder = ReaderBuilder::new(schema.clone()).build_decoder()?;
+
+        encode_fn(items, g, &mut decoder, &mut writer)?;
+
+        writer.close()?;
+        Ok::<_, GraphError>(())
+    })?;
+
+    Ok(())
+}
+
 pub(crate) fn derive_schema(
     prop_meta: &PropMapper,
     id_type: Option<GidType>,
@@ -178,14 +329,15 @@ pub(crate) fn derive_schema(
     } else {
         make_schema(DataType::UInt64, fields)
     };
+
     Ok(schema)
 }
 
 fn arrow_fields(meta: &PropMapper) -> Vec<Field> {
-    meta.get_keys()
-        .into_iter()
-        .filter_map(|name| {
-            let prop_id = meta.get_id(&name)?;
+    meta.keys()
+        .iter()
+        .zip(meta.ids())
+        .filter_map(|(name, prop_id)| {
             meta.get_dtype(prop_id)
                 .map(move |prop_type| (name, prop_type))
         })
@@ -197,7 +349,10 @@ fn arrow_fields(meta: &PropMapper) -> Vec<Field> {
 }
 
 fn ls_parquet_files(dir: &Path) -> Result<impl Iterator<Item = PathBuf>, GraphError> {
-    Ok(std::fs::read_dir(dir)?
+    Ok(std::fs::read_dir(dir)
+        .inspect_err(|err| {
+            eprintln!("Error reading directory {}: {}", dir.display(), err);
+        })? // print out the path if it's missing
         .filter_map(Result::ok)
         .map(|entry| entry.path())
         .filter(|path| path.is_file() && path.extension().is_some_and(|ext| ext == "parquet")))
@@ -233,63 +388,105 @@ fn collect_prop_columns(
                 });
             Ok((cols, graph_type))
         };
+
     let mut prop_columns = vec![];
     let mut g_type: Option<GraphType> = None;
-    for path in ls_parquet_files(path)? {
+
+    // Collect columns from just the first file
+    if let Some(path) = ls_parquet_files(path)?.next() {
         let (columns, tpe) = prop_columns_fn(&path, exclude)?;
+
         if g_type.is_none() {
             g_type = tpe;
         }
+
         prop_columns.extend_from_slice(&columns);
     }
-    prop_columns.sort();
-    prop_columns.dedup();
+
     Ok((prop_columns, g_type))
 }
 
+fn decode_graph_type(path: impl AsRef<Path>) -> Result<GraphType, GraphError> {
+    let c_graph_path = path.as_ref().join(GRAPH_C_PATH);
+
+    // Assume event graph as default
+    if !std::fs::exists(&c_graph_path)? {
+        return Ok(GraphType::EventGraph);
+    }
+
+    let exclude = vec![TIME_COL];
+    let (_, g_type) = collect_prop_columns(&c_graph_path, &exclude)?;
+
+    g_type.ok_or_else(|| GraphError::LoadFailure("Graph type not found".to_string()))
+}
+
+pub fn decode_graph_metadata(
+    path: &impl GraphPaths,
+) -> Result<Vec<(String, Option<Prop>)>, GraphError> {
+    let c_graph_path = path.graph_path()?.join(GRAPH_C_PATH);
+    let exclude = vec![TIME_COL];
+    let (c_props, _) = collect_prop_columns(&c_graph_path, &exclude)?;
+    let c_props = c_props.iter().map(|s| s.as_str()).collect::<Vec<_>>();
+    let mut result: Vec<(String, Option<Prop>)> =
+        c_props.iter().map(|s| (s.to_string(), None)).collect();
+
+    for path in get_parquet_file_paths(&c_graph_path)? {
+        let df_view = process_parquet_file_to_df(path.as_path(), Some(&c_props), None, None)?;
+        for chunk in df_view.chunks {
+            let chunk = chunk?;
+            for (col, res) in chunk.chunk.into_iter().zip(&mut result) {
+                if let Some(value) = lift_property_col(&col).get(0) {
+                    res.1 = Some(value);
+                }
+            }
+        }
+    }
+    Ok(result)
+}
+
 fn decode_graph_storage(
     path: impl AsRef<Path>,
-    expected_gt: GraphType,
     batch_size: Option<usize>,
+    path_for_decoded_graph: Option<&Path>,
+    config: Config,
 ) -> Result<Arc<Storage>, GraphError> {
-    let g = Arc::new(Storage::default());
+    let graph = if let Some(storage_path) = path_for_decoded_graph {
+        Arc::new(Storage::new_at_path_with_config(storage_path, config)?)
+    } else {
+        Arc::new(Storage::new_with_config(config)?)
+    };
 
     let c_graph_path = path.as_ref().join(GRAPH_C_PATH);
 
-    let g_type = {
+    {
         let exclude = vec![TIME_COL];
-        let (c_props, g_type) = collect_prop_columns(&c_graph_path, &exclude)?;
+        let (c_props, _) = collect_prop_columns(&c_graph_path, &exclude)?;
         let c_props = c_props.iter().map(|s| s.as_str()).collect::<Vec<_>>();
+
         load_graph_props_from_parquet(
-            &g,
+            &graph,
             &c_graph_path,
             TIME_COL,
+            None,
             &[],
             &c_props,
             batch_size,
             None,
         )?;
-
-        g_type.ok_or_else(|| GraphError::LoadFailure("Graph type not found".to_string()))?
-    };
-
-    if g_type != expected_gt {
-        return Err(GraphError::LoadFailure(format!(
-            "Expected graph type {:?}, got {:?}",
-            expected_gt, g_type
-        )));
     }
 
     let t_graph_path = path.as_ref().join(GRAPH_T_PATH);
 
     if std::fs::exists(&t_graph_path)? {
-        let exclude = vec![TIME_COL];
+        let exclude = vec![TIME_COL, SECONDARY_INDEX_COL];
         let (t_props, _) = collect_prop_columns(&t_graph_path, &exclude)?;
         let t_props = t_props.iter().map(|s| s.as_str()).collect::<Vec<_>>();
+
         load_graph_props_from_parquet(
-            &g,
+            &graph,
             &t_graph_path,
             TIME_COL,
+            Some(SECONDARY_INDEX_COL),
             &t_props,
             &[],
             batch_size,
@@ -297,55 +494,72 @@ fn decode_graph_storage(
         )?;
     }
 
-    let t_node_path = path.as_ref().join(NODES_T_PATH);
-    if std::fs::exists(&t_node_path)? {
-        let exclude = vec![NODE_ID, TIME_COL, TYPE_COL];
-        let (t_prop_columns, _) = collect_prop_columns(&t_node_path, &exclude)?;
-        let t_prop_columns = t_prop_columns
+    let c_node_path = path.as_ref().join(NODES_C_PATH);
+
+    if std::fs::exists(&c_node_path)? {
+        let exclude = vec![NODE_ID_COL, NODE_VID_COL, TYPE_COL, TYPE_ID_COL];
+        let (c_prop_columns, _) = collect_prop_columns(&c_node_path, &exclude)?;
+        let c_prop_columns = c_prop_columns
             .iter()
             .map(|s| s.as_str())
             .collect::<Vec<_>>();
 
-        load_nodes_from_parquet(
-            &g,
-            &t_node_path,
-            TIME_COL,
-            NODE_ID,
+        load_node_metadata_from_parquet(
+            &graph,
+            &c_node_path,
+            NODE_ID_COL,
             None,
             Some(TYPE_COL),
-            &t_prop_columns,
-            &[],
+            Some(NODE_VID_COL),
+            Some(TYPE_ID_COL),
+            &c_prop_columns,
             None,
             batch_size,
             None,
         )?;
     }
 
-    let c_node_path = path.as_ref().join(NODES_C_PATH);
-    if std::fs::exists(&c_node_path)? {
-        let exclude = vec![NODE_ID, TYPE_COL];
-        let (c_prop_columns, _) = collect_prop_columns(&c_node_path, &exclude)?;
-        let c_prop_columns = c_prop_columns
+    let t_node_path = path.as_ref().join(NODES_T_PATH);
+
+    if std::fs::exists(&t_node_path)? {
+        let exclude = vec![NODE_VID_COL, TIME_COL, SECONDARY_INDEX_COL];
+        let (t_prop_columns, _) = collect_prop_columns(&t_node_path, &exclude)?;
+        let t_prop_columns = t_prop_columns
             .iter()
             .map(|s| s.as_str())
             .collect::<Vec<_>>();
 
-        load_node_metadata_from_parquet(
-            &g,
-            &c_node_path,
-            NODE_ID,
+        load_nodes_from_parquet(
+            &graph,
+            &t_node_path,
+            TIME_COL,
+            Some(SECONDARY_INDEX_COL),
+            NODE_VID_COL,
+            None,
+            None,
+            &t_prop_columns,
+            &[],
+            None,
             None,
-            Some(TYPE_COL),
-            &c_prop_columns,
             None,
             batch_size,
+            false,
             None,
         )?;
     }
 
-    let exclude = vec![TIME_COL, SRC_COL, DST_COL, LAYER_COL];
     let t_edge_path = path.as_ref().join(EDGES_T_PATH);
+
     if std::fs::exists(&t_edge_path)? {
+        let exclude = vec![
+            TIME_COL,
+            SECONDARY_INDEX_COL,
+            SRC_COL_ID,
+            DST_COL_ID,
+            LAYER_COL,
+            LAYER_ID_COL,
+            EDGE_COL_ID,
+        ];
         let (t_prop_columns, _) = collect_prop_columns(&t_edge_path, &exclude)?;
         let t_prop_columns = t_prop_columns
             .iter()
@@ -353,38 +567,53 @@ fn decode_graph_storage(
             .collect::<Vec<_>>();
 
         load_edges_from_parquet(
-            &g,
+            &graph,
             &t_edge_path,
-            TIME_COL,
-            SRC_COL,
-            DST_COL,
+            ColumnNames::new(
+                TIME_COL,
+                Some(SECONDARY_INDEX_COL),
+                SRC_COL_ID,
+                DST_COL_ID,
+                Some(LAYER_COL),
+            )
+            .with_layer_id_col(LAYER_ID_COL)
+            .with_edge_id_col(EDGE_COL_ID),
+            false,
             &t_prop_columns,
             &[],
             None,
             None,
-            Some(LAYER_COL),
             batch_size,
             None,
         )?;
     }
 
     let d_edge_path = path.as_ref().join(EDGES_D_PATH);
+
     if std::fs::exists(&d_edge_path)? {
         load_edge_deletions_from_parquet(
-            g.core_graph(),
+            graph.core_graph(),
             &d_edge_path,
-            TIME_COL,
-            SRC_COL,
-            DST_COL,
+            ColumnNames::new(
+                TIME_COL,
+                Some(SECONDARY_INDEX_COL),
+                SRC_COL_ID,
+                DST_COL_ID,
+                Some(LAYER_COL),
+            )
+            .with_layer_id_col(LAYER_ID_COL)
+            .with_edge_id_col(EDGE_COL_ID),
             None,
-            Some(LAYER_COL),
+            false,
             batch_size,
             None,
         )?;
     }
 
     let c_edge_path = path.as_ref().join(EDGES_C_PATH);
+
     if std::fs::exists(&c_edge_path)? {
+        let exclude = vec![SRC_COL_ID, DST_COL_ID, LAYER_COL, EDGE_COL_ID];
         let (c_prop_columns, _) = collect_prop_columns(&c_edge_path, &exclude)?;
         let metadata = c_prop_columns
             .iter()
@@ -392,53 +621,62 @@ fn decode_graph_storage(
             .collect::<Vec<_>>();
 
         load_edge_metadata_from_parquet(
-            &g,
+            &graph,
             &c_edge_path,
-            SRC_COL,
-            DST_COL,
+            SRC_COL_ID,
+            DST_COL_ID,
             &metadata,
             None,
             None,
             Some(LAYER_COL),
             batch_size,
             None,
+            false,
         )?;
     }
-
-    Ok(g)
+    Ok(graph)
 }
+
 impl ParquetDecoder for Graph {
-    fn decode_parquet(path: impl AsRef<Path>) -> Result<Self, GraphError>
-    where
-        Self: Sized,
-    {
-        let gs = decode_graph_storage(path, GraphType::EventGraph, None)?;
-        Ok(Graph::from_storage(gs))
+    fn decode_parquet(
+        path: impl AsRef<Path>,
+        path_for_decoded_graph: Option<&Path>,
+        config: Config,
+    ) -> Result<Self, GraphError> {
+        let batch_size = None;
+        let storage = decode_graph_storage(&path, batch_size, path_for_decoded_graph, config)?;
+        Ok(Graph::from_storage(storage))
     }
 }
 
 impl ParquetDecoder for PersistentGraph {
-    fn decode_parquet(path: impl AsRef<Path>) -> Result<Self, GraphError>
-    where
-        Self: Sized,
-    {
-        let gs = decode_graph_storage(path, GraphType::PersistentGraph, None)?;
-        Ok(PersistentGraph(gs))
+    fn decode_parquet(
+        path: impl AsRef<Path>,
+        path_for_decoded_graph: Option<&Path>,
+        config: Config,
+    ) -> Result<Self, GraphError> {
+        let batch_size = None;
+        let storage = decode_graph_storage(&path, batch_size, path_for_decoded_graph, config)?;
+        Ok(PersistentGraph(storage))
     }
 }
 
 impl ParquetDecoder for MaterializedGraph {
-    fn decode_parquet(path: impl AsRef<Path>) -> Result<Self, GraphError>
-    where
-        Self: Sized,
-    {
-        // Try to decode as EventGraph first
-        match decode_graph_storage(path.as_ref(), GraphType::EventGraph, None) {
-            Ok(gs) => Ok(MaterializedGraph::EventGraph(Graph::from_storage(gs))),
-            Err(_) => {
-                // If that fails, try PersistentGraph
-                let gs = decode_graph_storage(path.as_ref(), GraphType::PersistentGraph, None)?;
-                Ok(MaterializedGraph::PersistentGraph(PersistentGraph(gs)))
+    fn decode_parquet(
+        path: impl AsRef<Path>,
+        path_for_decoded_graph: Option<&Path>,
+        config: Config,
+    ) -> Result<Self, GraphError> {
+        let batch_size = None;
+        let graph_type = decode_graph_type(&path)?;
+        let storage = decode_graph_storage(&path, batch_size, path_for_decoded_graph, config)?;
+
+        match graph_type {
+            GraphType::EventGraph => {
+                Ok(MaterializedGraph::EventGraph(Graph::from_storage(storage)))
+            }
+            GraphType::PersistentGraph => {
+                Ok(MaterializedGraph::PersistentGraph(PersistentGraph(storage)))
             }
         }
     }
diff --git a/raphtory/src/serialise/parquet/model.rs b/raphtory/src/serialise/parquet/model.rs
index 549fcb168d..e75d829334 100644
--- a/raphtory/src/serialise/parquet/model.rs
+++ b/raphtory/src/serialise/parquet/model.rs
@@ -1,63 +1,25 @@
-use super::{Prop, DST_COL, LAYER_COL, NODE_ID, SRC_COL, TIME_COL, TYPE_COL};
+use super::{Prop, LAYER_COL, NODE_ID_COL, SECONDARY_INDEX_COL, TIME_COL, TYPE_COL};
 use crate::{
     db::{
         api::view::StaticGraphViewOps,
         graph::{edge::EdgeView, node::NodeView},
     },
     prelude::*,
+    serialise::parquet::{
+        DST_COL_ID, EDGE_COL_ID, LAYER_ID_COL, NODE_VID_COL, SRC_COL_ID, TYPE_ID_COL,
+    },
 };
 use arrow::datatypes::DataType;
 use raphtory_api::core::{
-    entities::GidType,
+    entities::{properties::prop::SerdeArrowProp, GidType, LayerId},
     storage::{arc_str::ArcStr, timeindex::EventTime},
 };
 use raphtory_storage::graph::graph::GraphStorage;
 use serde::{
-    ser::{Error, SerializeMap, SerializeSeq},
+    ser::{Error, SerializeMap},
     Serialize,
 };
 
-pub(crate) struct ParquetProp<'a>(pub &'a Prop);
-
-impl<'a> Serialize for ParquetProp<'a> {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        match self.0 {
-            Prop::I32(i) => serializer.serialize_i32(*i),
-            Prop::I64(i) => serializer.serialize_i64(*i),
-            Prop::F32(f) => serializer.serialize_f32(*f),
-            Prop::F64(f) => serializer.serialize_f64(*f),
-            Prop::U8(u) => serializer.serialize_u8(*u),
-            Prop::U16(u) => serializer.serialize_u16(*u),
-            Prop::U32(u) => serializer.serialize_u32(*u),
-            Prop::U64(u) => serializer.serialize_u64(*u),
-            Prop::Str(s) => serializer.serialize_str(s),
-            Prop::Bool(b) => serializer.serialize_bool(*b),
-            Prop::DTime(dt) => serializer.serialize_i64(dt.timestamp_millis()),
-            Prop::NDTime(dt) => serializer.serialize_i64(dt.and_utc().timestamp_millis()),
-            Prop::List(l) => {
-                let mut state = serializer.serialize_seq(Some(l.len()))?;
-                for prop in l.iter() {
-                    state.serialize_element(&ParquetProp(prop))?;
-                }
-                state.end()
-            }
-            Prop::Map(m) => {
-                let mut state = serializer.serialize_map(Some(m.len()))?;
-                for (k, v) in m.iter() {
-                    state.serialize_entry(k, &ParquetProp(v))?;
-                }
-                state.end()
-            }
-
-            Prop::Decimal(dec) => serializer.serialize_str(&dec.to_string()),
-            _ => todo!(),
-        }
-    }
-}
-
 #[derive(Debug)]
 struct ParquetGID(GID);
 
@@ -91,13 +53,21 @@ impl<'a, G: StaticGraphViewOps> Serialize for ParquetTEdge<'a, G> {
             .layer_name()
             .map_err(|_| S::Error::custom("Edge has no layer"))?;
 
+        let layer_id = edge
+            .edge
+            .layer()
+            .ok_or_else(|| S::Error::custom("Edge has no layer"))?;
+
         state.serialize_entry(TIME_COL, &t.0)?;
-        state.serialize_entry(SRC_COL, &ParquetGID(edge.src().id()))?;
-        state.serialize_entry(DST_COL, &ParquetGID(edge.dst().id()))?;
+        state.serialize_entry(SECONDARY_INDEX_COL, &t.1)?;
+        state.serialize_entry(SRC_COL_ID, &edge.src().node.0)?;
+        state.serialize_entry(DST_COL_ID, &edge.dst().node.0)?;
+        state.serialize_entry(EDGE_COL_ID, &edge.edge.pid())?;
         state.serialize_entry(LAYER_COL, &layer)?;
+        state.serialize_entry(LAYER_ID_COL, &layer_id.0)?;
 
         for (name, prop) in edge.properties().temporal().iter_latest() {
-            state.serialize_entry(&name, &ParquetProp(&prop))?;
+            state.serialize_entry(&name, &SerdeArrowProp(&prop))?;
         }
 
         state.end()
@@ -118,12 +88,13 @@ impl<'a, G: StaticGraphViewOps> Serialize for ParquetCEdge<'a, G> {
             .layer_name()
             .map_err(|_| S::Error::custom("Edge has no layer"))?;
 
-        state.serialize_entry(SRC_COL, &ParquetGID(edge.src().id()))?;
-        state.serialize_entry(DST_COL, &ParquetGID(edge.dst().id()))?;
+        state.serialize_entry(SRC_COL_ID, &(edge.src().node.0))?;
+        state.serialize_entry(DST_COL_ID, &(edge.dst().node.0))?;
+        state.serialize_entry(EDGE_COL_ID, &(edge.edge.pid().0))?;
         state.serialize_entry(LAYER_COL, &layer)?;
 
         for (name, prop) in edge.metadata().iter_filtered() {
-            state.serialize_entry(&name, &ParquetProp(&prop))?;
+            state.serialize_entry(&name, &SerdeArrowProp(&prop))?;
         }
 
         state.end()
@@ -132,6 +103,7 @@ impl<'a, G: StaticGraphViewOps> Serialize for ParquetCEdge<'a, G> {
 
 pub(crate) struct ParquetDelEdge<'a, G> {
     pub layer: &'a str,
+    pub layer_id: LayerId,
     pub edge: EdgeView<&'a G>,
     pub del: EventTime,
 }
@@ -145,9 +117,12 @@ impl<'a, G: StaticGraphViewOps> Serialize for ParquetDelEdge<'a, G> {
         let mut state = serializer.serialize_map(None)?;
 
         state.serialize_entry(TIME_COL, &self.del.0)?;
-        state.serialize_entry(SRC_COL, &ParquetGID(edge.src().id()))?;
-        state.serialize_entry(DST_COL, &ParquetGID(edge.dst().id()))?;
+        state.serialize_entry(SECONDARY_INDEX_COL, &self.del.1)?;
+        state.serialize_entry(SRC_COL_ID, &(edge.src().node.0))?;
+        state.serialize_entry(DST_COL_ID, &(edge.dst().node.0))?;
+        state.serialize_entry(EDGE_COL_ID, &(edge.edge.pid().0))?;
         state.serialize_entry(LAYER_COL, &self.layer)?;
+        state.serialize_entry(LAYER_ID_COL, &self.layer_id.0)?;
 
         state.end()
     }
@@ -167,12 +142,12 @@ impl<'a> Serialize for ParquetTNode<'a> {
     {
         let mut state = serializer.serialize_map(None)?;
 
-        state.serialize_entry(NODE_ID, &ParquetGID(self.node.id()))?;
+        state.serialize_entry(NODE_VID_COL, &self.node.node.0)?;
         state.serialize_entry(TIME_COL, &self.t.0)?;
-        state.serialize_entry(TYPE_COL, &self.node.node_type())?;
+        state.serialize_entry(SECONDARY_INDEX_COL, &self.t.1)?;
 
         for (name, prop) in self.props.iter() {
-            state.serialize_entry(&self.cols[*name], &ParquetProp(prop))?;
+            state.serialize_entry(&self.cols[*name], &SerdeArrowProp(prop))?;
         }
 
         state.end()
@@ -190,11 +165,13 @@ impl<'a> Serialize for ParquetCNode<'a> {
     {
         let mut state = serializer.serialize_map(None)?;
 
-        state.serialize_entry(NODE_ID, &ParquetGID(self.node.id()))?;
+        state.serialize_entry(NODE_ID_COL, &ParquetGID(self.node.id()))?;
+        state.serialize_entry(NODE_VID_COL, &self.node.node.0)?;
         state.serialize_entry(TYPE_COL, &self.node.node_type())?;
+        state.serialize_entry(TYPE_ID_COL, &self.node.node_type_id())?;
 
         for (name, prop) in self.node.metadata().iter_filtered() {
-            state.serialize_entry(&name, &ParquetProp(&prop))?;
+            state.serialize_entry(&name, &SerdeArrowProp(&prop))?;
         }
 
         state.end()
diff --git a/raphtory/src/serialise/parquet/nodes.rs b/raphtory/src/serialise/parquet/nodes.rs
index c67549c766..0852d52645 100644
--- a/raphtory/src/serialise/parquet/nodes.rs
+++ b/raphtory/src/serialise/parquet/nodes.rs
@@ -4,12 +4,13 @@ use crate::{
     errors::GraphError,
     serialise::parquet::{
         model::{ParquetCNode, ParquetTNode},
-        run_encode, NODES_C_PATH, NODES_T_PATH, NODE_ID, TIME_COL, TYPE_COL,
+        run_encode_indexed, NODES_C_PATH, NODES_T_PATH, NODE_ID_COL, NODE_VID_COL,
+        SECONDARY_INDEX_COL, TIME_COL, TYPE_COL, TYPE_ID_COL,
     },
 };
 use arrow::datatypes::{DataType, Field};
 use itertools::Itertools;
-use raphtory_api::{core::entities::VID, iter::IntoDynBoxed};
+use raphtory_api::iter::IntoDynBoxed;
 use raphtory_storage::graph::graph::GraphStorage;
 use std::path::Path;
 
@@ -17,37 +18,33 @@ pub(crate) fn encode_nodes_tprop(
     g: &GraphStorage,
     path: impl AsRef<Path>,
 ) -> Result<(), GraphError> {
-    run_encode(
+    run_encode_indexed(
         g,
         g.node_meta().temporal_prop_mapper(),
-        g.unfiltered_num_nodes(),
+        g.nodes().row_groups_par_iter(),
         path,
         NODES_T_PATH,
-        |id_type| {
+        |_| {
             vec![
-                Field::new(NODE_ID, id_type.clone(), false),
+                Field::new(NODE_VID_COL, DataType::UInt64, false),
                 Field::new(TIME_COL, DataType::Int64, false),
-                Field::new(TYPE_COL, DataType::Utf8, true),
+                Field::new(SECONDARY_INDEX_COL, DataType::UInt64, true),
             ]
         },
         |nodes, g, decoder, writer| {
             let row_group_size = 100_000;
+            let nodes = nodes.collect::<Vec<_>>();
 
-            let cols = g
-                .node_meta()
-                .temporal_prop_mapper()
-                .get_keys()
-                .into_iter()
-                .collect_vec();
+            let nodes = nodes.into_iter();
+
+            let cols = g.node_meta().temporal_prop_mapper().all_keys();
             let cols = &cols;
             for node_rows in nodes
-                .into_iter()
-                .map(VID)
                 .map(|vid| NodeView::new_internal(g, vid))
                 .flat_map(move |node| {
                     GenLockedIter::from(node, |node| {
                         node.rows()
-                            .map(|(t, props)| ParquetTNode {
+                            .map(|(t, _, props)| ParquetTNode {
                                 node: *node,
                                 cols,
                                 t,
@@ -75,36 +72,39 @@ pub(crate) fn encode_nodes_cprop(
     g: &GraphStorage,
     path: impl AsRef<Path>,
 ) -> Result<(), GraphError> {
-    run_encode(
+    run_encode_indexed(
         g,
         g.node_meta().metadata_mapper(),
-        g.unfiltered_num_nodes(),
+        g.nodes().row_groups_par_iter(),
         path,
         NODES_C_PATH,
         |id_type| {
             vec![
-                Field::new(NODE_ID, id_type.clone(), false),
+                Field::new(NODE_ID_COL, id_type.clone(), false),
+                Field::new(NODE_VID_COL, DataType::UInt64, false),
                 Field::new(TYPE_COL, DataType::Utf8, true),
+                Field::new(TYPE_ID_COL, DataType::UInt64, true),
             ]
         },
         |nodes, g, decoder, writer| {
             let row_group_size = 100_000;
 
             for node_rows in nodes
-                .into_iter()
-                .map(VID)
                 .map(|vid| NodeView::new_internal(g, vid))
                 .map(move |node| ParquetCNode { node })
                 .chunks(row_group_size)
                 .into_iter()
                 .map(|chunk| chunk.collect_vec())
+            // scope for the decoder
             {
                 decoder.serialize(&node_rows)?;
+
                 if let Some(rb) = decoder.flush()? {
                     writer.write(&rb)?;
                     writer.flush()?;
                 }
             }
+
             Ok(())
         },
     )
diff --git a/raphtory/src/serialise/proto_ext.rs b/raphtory/src/serialise/proto/ext.rs
similarity index 90%
rename from raphtory/src/serialise/proto_ext.rs
rename to raphtory/src/serialise/proto/ext.rs
index 63a735a666..bd93a9843c 100644
--- a/raphtory/src/serialise/proto_ext.rs
+++ b/raphtory/src/serialise/proto/ext.rs
@@ -1,29 +1,23 @@
-use super::proto::{
-    prop::Array,
-    prop_type::{Array as ArrayType, Scalar as ScalarType},
-};
-use crate::{
-    errors::GraphError,
-    serialise::proto::{
-        self,
-        graph_update::{
-            DelEdge, PropPair, Update, UpdateEdgeCProps, UpdateEdgeTProps, UpdateGraphCProps,
-            UpdateGraphTProps, UpdateNodeCProps, UpdateNodeTProps, UpdateNodeType,
-        },
-        new_meta::{
-            Meta, NewEdgeCProp, NewEdgeTProp, NewGraphCProp, NewGraphTProp, NewLayer, NewNodeCProp,
-            NewNodeTProp, NewNodeType,
-        },
-        new_node, prop,
-        prop_type::{PType, PropType as SPropType},
-        GraphUpdate, NewEdge, NewMeta, NewNode,
+use super::proto_generated::{
+    self,
+    graph_update::{
+        DelEdge, PropPair, Update, UpdateEdgeCProps, UpdateEdgeTProps, UpdateGraphCProps,
+        UpdateGraphTProps, UpdateNodeCProps, UpdateNodeTProps, UpdateNodeType,
+    },
+    new_meta::{
+        Meta, NewEdgeCProp, NewEdgeTProp, NewGraphCProp, NewGraphTProp, NewLayer, NewNodeCProp,
+        NewNodeTProp, NewNodeType,
     },
+    new_node, prop,
+    prop_type::{Array as ArrayType, PType, PropType as SPropType, Scalar as ScalarType},
+    GraphUpdate, NewEdge, NewMeta, NewNode,
 };
+use crate::errors::GraphError;
 use chrono::{DateTime, Datelike, NaiveDate, NaiveDateTime, NaiveTime, Timelike};
 use raphtory_api::core::{
     entities::{
         properties::prop::{Prop, PropType},
-        GidRef, EID, VID,
+        GidRef, LayerId, EID, VID,
     },
     storage::{
         arc_str::ArcStr,
@@ -32,9 +26,6 @@ use raphtory_api::core::{
 };
 use std::{borrow::Borrow, collections::HashMap, sync::Arc};
 
-#[cfg(feature = "arrow")]
-use raphtory_api::core::entities::properties::prop::PropArray;
-
 fn as_proto_prop_type(p_type: &PropType) -> Option<SPropType> {
     let val = match p_type {
         PropType::Str => SPropType::Str,
@@ -60,30 +51,32 @@ fn as_proto_prop_type(p_type: &PropType) -> Option<SPropType> {
 
 fn as_proto_prop_type2(p_type: &PropType) -> Option<PType> {
     match p_type {
-        PropType::Array(tpe) => {
+        PropType::List(tpe) => {
             let prop_type = as_proto_prop_type(tpe)?;
             Some(PType {
-                kind: Some(proto::prop_type::p_type::Kind::Array(ArrayType {
+                kind: Some(proto_generated::prop_type::p_type::Kind::Array(ArrayType {
                     p_type: prop_type.into(),
                 })),
             })
         }
         _ => Some(PType {
-            kind: Some(proto::prop_type::p_type::Kind::Scalar(ScalarType {
-                p_type: as_proto_prop_type(p_type)?.into(),
-            })),
+            kind: Some(proto_generated::prop_type::p_type::Kind::Scalar(
+                ScalarType {
+                    p_type: as_proto_prop_type(p_type)?.into(),
+                },
+            )),
         }),
     }
 }
 
 fn as_prop_type2(p_type: PType) -> Option<PropType> {
     match p_type.kind? {
-        proto::prop_type::p_type::Kind::Scalar(scalar) => as_prop_type(scalar.p_type()),
-        proto::prop_type::p_type::Kind::Array(array) => {
+        proto_generated::prop_type::p_type::Kind::Scalar(scalar) => as_prop_type(scalar.p_type()),
+        proto_generated::prop_type::p_type::Kind::Array(array) => {
             let p_type = as_prop_type(array.p_type())?;
-            Some(PropType::Array(Box::new(p_type)))
+            Some(PropType::List(Box::new(p_type)))
         }
-        proto::prop_type::p_type::Kind::Decimal(decimal) => Some(PropType::Decimal {
+        proto_generated::prop_type::p_type::Kind::Decimal(decimal) => Some(PropType::Decimal {
             scale: decimal.scale as i64,
         }),
     }
@@ -417,7 +410,7 @@ impl GraphUpdate {
     fn update_edge_tprops(
         eid: EID,
         time: EventTime,
-        layer_id: usize,
+        layer_id: LayerId,
         properties: impl Iterator<Item = (usize, impl Borrow<Prop>)>,
     ) -> Self {
         let properties = collect_proto_props(properties);
@@ -425,7 +418,7 @@ impl GraphUpdate {
             eid: eid.0 as u64,
             time: time.t(),
             secondary: time.i() as u64,
-            layer_id: layer_id as u64,
+            layer_id: layer_id.0 as u64,
             properties,
         };
         Self::new(Update::UpdateEdgeTprops(inner))
@@ -433,24 +426,24 @@ impl GraphUpdate {
 
     fn update_edge_cprops(
         eid: EID,
-        layer_id: usize,
+        layer_id: LayerId,
         properties: impl Iterator<Item = (usize, impl Borrow<Prop>)>,
     ) -> Self {
         let properties = collect_proto_props(properties);
         let inner = UpdateEdgeCProps {
             eid: eid.0 as u64,
-            layer_id: layer_id as u64,
+            layer_id: layer_id.0 as u64,
             properties,
         };
         Self::new(Update::UpdateEdgeCprops(inner))
     }
 
-    fn del_edge(eid: EID, layer_id: usize, time: EventTime) -> Self {
+    fn del_edge(eid: EID, layer_id: LayerId, time: EventTime) -> Self {
         let inner = DelEdge {
             eid: eid.as_u64(),
             time: time.t(),
             secondary: time.i() as u64,
-            layer_id: layer_id as u64,
+            layer_id: layer_id.0 as u64,
         };
         Self::new(Update::DelEdge(inner))
     }
@@ -483,7 +476,7 @@ impl PropPair {
     }
 }
 
-impl proto::Graph {
+impl proto_generated::Graph {
     pub fn new_edge(&mut self, src: VID, dst: VID, eid: EID) {
         let edge = NewEdge {
             src: src.as_u64(),
@@ -582,7 +575,7 @@ impl proto::Graph {
         &mut self,
         eid: EID,
         time: EventTime,
-        layer_id: usize,
+        layer_id: LayerId,
         properties: impl Iterator<Item = (usize, impl Borrow<Prop>)>,
     ) {
         self.updates.push(GraphUpdate::update_edge_tprops(
@@ -593,14 +586,14 @@ impl proto::Graph {
     pub fn update_edge_cprops(
         &mut self,
         eid: EID,
-        layer_id: usize,
+        layer_id: LayerId,
         properties: impl Iterator<Item = (usize, impl Borrow<Prop>)>,
     ) {
         self.updates
             .push(GraphUpdate::update_edge_cprops(eid, layer_id, properties));
     }
 
-    pub fn del_edge(&mut self, eid: EID, layer_id: usize, time: EventTime) {
+    pub fn del_edge(&mut self, eid: EID, layer_id: LayerId, time: EventTime) {
         self.updates
             .push(GraphUpdate::del_edge(eid, layer_id, time))
     }
@@ -627,13 +620,14 @@ fn as_prop_value(value: Option<&prop::Value>) -> Result<Option<Prop>, GraphError
         prop::Value::F32(f) => Some(Prop::F32(*f)),
         prop::Value::F64(f) => Some(Prop::F64(*f)),
         prop::Value::Str(s) => Some(Prop::Str(ArcStr::from(s.as_str()))),
-        prop::Value::Prop(props) => Some(Prop::List(Arc::new(
+        prop::Value::Prop(props) => Some(Prop::List(
             props
                 .properties
                 .iter()
                 .filter_map(|prop| as_prop_value(prop.value.as_ref()).transpose())
-                .collect::<Result<Vec<_>, _>>()?,
-        ))),
+                .collect::<Result<Vec<_>, _>>()?
+                .into(),
+        )),
         prop::Value::Map(dict) => Some(Prop::Map(Arc::new(
             dict.map
                 .iter()
@@ -663,7 +657,7 @@ fn as_prop_value(value: Option<&prop::Value>) -> Result<Option<Prop>, GraphError
         prop::Value::DTime(dt) => Some(Prop::DTime(
             DateTime::parse_from_rfc3339(dt).unwrap().into(),
         )),
-        prop::Value::Array(blob) => Some(Prop::Array(PropArray::from_vec_u8(&blob.data)?)),
+        prop::Value::Array(_) => None,
         _ => None,
     };
     Ok(value)
@@ -686,7 +680,7 @@ pub fn collect_props<'a>(
         .collect()
 }
 
-fn as_proto_prop(prop: &Prop) -> proto::Prop {
+fn as_proto_prop(prop: &Prop) -> proto_generated::Prop {
     let value: Option<prop::Value> = match prop {
         Prop::Bool(b) => Some(prop::Value::BoolValue(*b)),
         Prop::U8(u) => Some(prop::Value::U8((*u).into())),
@@ -699,7 +693,7 @@ fn as_proto_prop(prop: &Prop) -> proto::Prop {
         Prop::F64(f) => Some(prop::Value::F64(*f)),
         Prop::Str(s) => Some(prop::Value::Str(s.to_string())),
         Prop::List(list) => {
-            let properties = list.iter().map(as_proto_prop).collect();
+            let properties = list.iter().map(|p| as_proto_prop(&p)).collect();
             Some(prop::Value::Prop(prop::Props { properties }))
         }
         Prop::Map(map) => {
@@ -732,11 +726,8 @@ fn as_proto_prop(prop: &Prop) -> proto::Prop {
         Prop::DTime(dt) => Some(prop::Value::DTime(
             dt.to_rfc3339_opts(chrono::SecondsFormat::AutoSi, true),
         )),
-        Prop::Array(blob) => Some(prop::Value::Array(Array {
-            data: blob.to_vec_u8(),
-        })),
         Prop::Decimal(bd) => Some(prop::Value::Decimal(bd.to_string())),
     };
 
-    proto::Prop { value }
+    proto_generated::Prop { value }
 }
diff --git a/raphtory/src/serialise/proto/mod.rs b/raphtory/src/serialise/proto/mod.rs
new file mode 100644
index 0000000000..8911def7a3
--- /dev/null
+++ b/raphtory/src/serialise/proto/mod.rs
@@ -0,0 +1,226 @@
+use crate::{
+    core::entities::LayerIds,
+    db::{
+        api::{
+            properties::internal::{InternalMetadataOps, InternalTemporalPropertyViewOps},
+            view::MaterializedGraph,
+        },
+        graph::views::deletion_graph::PersistentGraph,
+    },
+    errors::GraphError,
+    prelude::Graph,
+};
+
+// Load the generated protobuf code from the build directory
+pub mod proto_generated {
+    include!(concat!(env!("OUT_DIR"), "/serialise.rs"));
+}
+
+use itertools::Itertools;
+use raphtory_api::core::{
+    entities::{
+        properties::{prop::Prop, tprop::TPropOps},
+        LayerId, VID,
+    },
+    storage::timeindex::TimeIndexOps,
+};
+use raphtory_storage::{
+    core_ops::CoreGraphOps,
+    graph::{
+        edges::edge_storage_ops::EdgeStorageOps, graph::GraphStorage,
+        nodes::node_storage_ops::NodeStorageOps,
+    },
+};
+use std::iter;
+
+pub mod ext;
+
+/// Trait for encoding a graph to protobuf format
+pub trait ProtoEncoder {
+    fn encode_to_proto(&self) -> proto_generated::Graph;
+}
+
+/// Trait for decoding a graph from protobuf format
+pub trait ProtoDecoder: Sized {
+    fn decode_from_proto(graph: &proto_generated::Graph) -> Result<Self, GraphError>;
+}
+
+macro_rules! zip_tprop_updates {
+    ($iter:expr) => {
+        &$iter
+            .map(|(key, values)| values.iter().map(move |(t, v)| (t, (key, v))))
+            .kmerge_by(|(left_t, _), (right_t, _)| left_t <= right_t)
+            .chunk_by(|(t, _)| *t)
+    };
+}
+
+impl ProtoEncoder for GraphStorage {
+    fn encode_to_proto(&self) -> proto_generated::Graph {
+        let storage = self.lock();
+        let mut graph = proto_generated::Graph::default();
+
+        // Graph Properties
+        let graph_meta = storage.graph_props_meta();
+        for (id, key) in graph_meta.metadata_mapper().read().iter_ids() {
+            graph.new_graph_cprop(key, id);
+        }
+        graph.update_graph_cprops(
+            storage
+                .metadata_ids()
+                .filter_map(|id| Some((id, storage.get_metadata(id)?))),
+        );
+
+        for (id, key, dtype) in graph_meta
+            .temporal_prop_mapper()
+            .locked()
+            .iter_ids_and_types()
+        {
+            graph.new_graph_tprop(key, id, dtype);
+        }
+
+        let t_props = graph_meta
+            .temporal_prop_mapper()
+            .locked()
+            .iter_ids_and_types()
+            .map(|(id, _, _)| storage.temporal_iter(id).map(move |(t, v)| (t, (id, v))))
+            .kmerge_by(|(left_t, _), (right_t, _)| left_t <= right_t)
+            .chunk_by(|(t, _)| *t);
+
+        for (t, group) in t_props.into_iter() {
+            graph.update_graph_tprops(t, group.map(|(_, v)| v));
+        }
+
+        // Layers
+        for (id, layer) in storage.edge_meta().layer_meta().read().iter_ids() {
+            graph.new_layer(layer, id);
+        }
+
+        // Node Types
+        for (id, node_type) in storage.node_meta().node_type_meta().read().iter_ids() {
+            graph.new_node_type(node_type, id);
+        }
+
+        // Node Properties
+        let n_const_meta = self.node_meta().metadata_mapper();
+        for (id, key, dtype) in n_const_meta.locked().iter_ids_and_types() {
+            graph.new_node_cprop(key, id, dtype);
+        }
+        let n_temporal_meta = self.node_meta().temporal_prop_mapper();
+        for (id, key, dtype) in n_temporal_meta.locked().iter_ids_and_types() {
+            graph.new_node_tprop(key, id, dtype);
+        }
+
+        // Nodes
+        let nodes = storage.nodes();
+        for node_id in 0..nodes.len() {
+            let node = nodes.node(VID(node_id));
+            graph.new_node(node.id(), node.vid(), node.node_type_id());
+
+            for (time, _, row) in node.temp_prop_rows() {
+                graph.update_node_tprops(node.vid(), time, row.into_iter());
+            }
+
+            graph.update_node_cprops(
+                node.vid(),
+                n_const_meta
+                    .ids()
+                    .flat_map(|i| node.constant_prop_layer(LayerId(0), i).map(|v| (i, v))),
+            );
+        }
+
+        // Edge Properties
+        let e_const_meta = self.edge_meta().metadata_mapper();
+        for (id, key, dtype) in e_const_meta.locked().iter_ids_and_types() {
+            graph.new_edge_cprop(key, id, dtype);
+        }
+        let e_temporal_meta = self.edge_meta().temporal_prop_mapper();
+        for (id, key, dtype) in e_temporal_meta.locked().iter_ids_and_types() {
+            graph.new_edge_tprop(key, id, dtype);
+        }
+
+        // Edges
+        let edges = storage.edges();
+        for edge in edges.iter(&LayerIds::All) {
+            let eid = edge.eid();
+            let edge = edge.as_ref();
+            graph.new_edge(edge.src(), edge.dst(), eid);
+            for layer_id in storage.unfiltered_layer_ids() {
+                for (t, props) in zip_tprop_updates!(e_temporal_meta
+                    .ids()
+                    .map(|i| (i, edge.temporal_prop_layer(layer_id, i))))
+                {
+                    graph.update_edge_tprops(eid, t, layer_id, props.map(|(_, v)| v));
+                }
+                for t in edge.additions(layer_id).iter() {
+                    graph.update_edge_tprops(eid, t, layer_id, iter::empty::<(usize, Prop)>());
+                }
+                for t in edge.deletions(layer_id).iter() {
+                    graph.del_edge(eid, layer_id, t);
+                }
+                graph.update_edge_cprops(
+                    eid,
+                    layer_id,
+                    e_const_meta
+                        .ids()
+                        .filter_map(|i| edge.metadata_layer(layer_id, i).map(|prop| (i, prop))),
+                );
+            }
+        }
+        graph
+    }
+}
+
+impl ProtoEncoder for Graph {
+    fn encode_to_proto(&self) -> proto_generated::Graph {
+        let mut graph = self.core_graph().encode_to_proto();
+        graph.set_graph_type(proto_generated::GraphType::Event);
+        graph
+    }
+}
+
+impl ProtoEncoder for PersistentGraph {
+    fn encode_to_proto(&self) -> proto_generated::Graph {
+        let mut graph = self.core_graph().encode_to_proto();
+        graph.set_graph_type(proto_generated::GraphType::Persistent);
+        graph
+    }
+}
+
+impl ProtoEncoder for MaterializedGraph {
+    fn encode_to_proto(&self) -> proto_generated::Graph {
+        match self {
+            MaterializedGraph::EventGraph(graph) => graph.encode_to_proto(),
+            MaterializedGraph::PersistentGraph(graph) => graph.encode_to_proto(),
+        }
+    }
+}
+
+impl ProtoDecoder for GraphStorage {
+    fn decode_from_proto(_graph: &proto_generated::Graph) -> Result<Self, GraphError> {
+        todo!("implement this")
+    }
+}
+
+impl ProtoDecoder for Graph {
+    fn decode_from_proto(_graph: &proto_generated::Graph) -> Result<Self, GraphError> {
+        todo!("implement this")
+    }
+}
+
+impl ProtoDecoder for PersistentGraph {
+    fn decode_from_proto(graph: &proto_generated::Graph) -> Result<Self, GraphError> {
+        match graph.graph_type() {
+            proto_generated::GraphType::Event => Err(GraphError::GraphLoadError),
+            proto_generated::GraphType::Persistent => {
+                let storage = GraphStorage::decode_from_proto(graph)?;
+                Ok(PersistentGraph::from_internal_graph(storage))
+            }
+        }
+    }
+}
+
+impl ProtoDecoder for MaterializedGraph {
+    fn decode_from_proto(_graph: &proto_generated::Graph) -> Result<Self, GraphError> {
+        todo!("implement this")
+    }
+}
diff --git a/raphtory/src/serialise/serialise.rs b/raphtory/src/serialise/serialise.rs
index 555fd1aa29..2623623e08 100644
--- a/raphtory/src/serialise/serialise.rs
+++ b/raphtory/src/serialise/serialise.rs
@@ -1,679 +1,212 @@
-use super::{proto_ext::PropTypeExt, GraphFolder};
 #[cfg(feature = "search")]
 use crate::prelude::IndexMutationOps;
 use crate::{
-    core::entities::{graph::tgraph::TemporalGraph, LayerIds},
-    db::{
-        api::view::{MaterializedGraph, StaticGraphViewOps},
-        graph::views::deletion_graph::PersistentGraph,
+    db::api::{
+        mutation::AdditionOps, storage::storage::PersistenceStrategy, view::StaticGraphViewOps,
     },
     errors::GraphError,
-    prelude::{AdditionOps, Graph},
     serialise::{
-        proto::{self, graph_update::*, new_meta::*, new_node::Gid},
-        proto_ext,
+        get_zip_graph_path,
+        metadata::GraphMetadata,
+        parquet::{ParquetDecoder, ParquetEncoder},
+        GraphFolder, GraphPaths, Metadata, RelativePath, DEFAULT_DATA_PATH, DEFAULT_GRAPH_PATH,
+        GRAPH_META_PATH, ROOT_META_PATH,
     },
 };
-use itertools::Itertools;
-use prost::Message;
-use raphtory_api::core::{
-    entities::{
-        properties::{
-            meta::PropMapper,
-            prop::{unify_types, Prop, PropType},
-            tprop::TPropOps,
-        },
-        GidRef, EID, VID,
-    },
-    storage::timeindex::{EventTime, TimeIndexOps},
-    Direction,
+use std::{
+    fs::File,
+    io::{Cursor, Read, Seek, Write},
 };
-use raphtory_storage::{
-    core_ops::CoreGraphOps,
-    graph::{
-        edges::edge_storage_ops::EdgeStorageOps, graph::GraphStorage,
-        nodes::node_storage_ops::NodeStorageOps,
-    },
-    mutation::{
-        addition_ops::InternalAdditionOps, property_addition_ops::InternalPropertyAdditionOps,
-    },
-};
-use rayon::prelude::*;
-use std::{iter, ops::Deref, sync::Arc};
-
-macro_rules! zip_tprop_updates {
-    ($iter:expr) => {
-        &$iter
-            .map(|(key, values)| values.iter().map(move |(t, v)| (t, (key, v))))
-            .kmerge_by(|(left_t, _), (right_t, _)| left_t <= right_t)
-            .chunk_by(|(t, _)| *t)
-    };
-}
+use storage::{Config, Extension};
+use zip::{write::SimpleFileOptions, ZipArchive, ZipWriter};
 
 pub trait StableEncode: StaticGraphViewOps + AdditionOps {
-    fn encode_to_proto(&self) -> proto::Graph;
-    fn encode_to_vec(&self) -> Vec<u8> {
-        self.encode_to_proto().encode_to_vec()
+    fn encode_to_zip<W: Write + Seek>(&self, writer: ZipWriter<W>) -> Result<(), GraphError>;
+
+    /// Encode the graph into bytes.
+    fn encode_to_bytes(&self) -> Result<Vec<u8>, GraphError>;
+
+    /// Encode the graph into the given path.
+    fn encode(&self, path: impl Into<GraphFolder>) -> Result<(), GraphError>;
+}
+
+impl<T: ParquetEncoder + StaticGraphViewOps + AdditionOps> StableEncode for T {
+    fn encode_to_zip<W: Write + Seek>(&self, mut writer: ZipWriter<W>) -> Result<(), GraphError> {
+        let graph_meta = GraphMetadata::from_graph(self);
+        writer.start_file(ROOT_META_PATH, SimpleFileOptions::default())?;
+        writer.write_all(&serde_json::to_vec(&RelativePath {
+            path: DEFAULT_DATA_PATH.to_string(),
+        })?)?;
+        writer.start_file(
+            [DEFAULT_DATA_PATH, GRAPH_META_PATH].join("/"),
+            SimpleFileOptions::default(),
+        )?;
+        writer.write_all(&serde_json::to_vec(&Metadata {
+            path: DEFAULT_GRAPH_PATH.to_string(),
+            meta: graph_meta,
+        })?)?;
+        let graph_prefix = [DEFAULT_DATA_PATH, DEFAULT_GRAPH_PATH].join("/");
+        self.encode_parquet_to_zip(&mut writer, graph_prefix)?;
+        // TODO: Encode Index to zip
+        writer.finish()?;
+        Ok(())
+    }
+
+    fn encode_to_bytes(&self) -> Result<Vec<u8>, GraphError> {
+        let mut bytes = Vec::new();
+        let writer = ZipWriter::new(Cursor::new(&mut bytes));
+        self.encode_to_zip(writer)?;
+        Ok(bytes)
     }
 
     fn encode(&self, path: impl Into<GraphFolder>) -> Result<(), GraphError> {
-        let folder = path.into();
-        folder.write_graph(self)
-    }
-}
-
-pub trait StableDecode: InternalStableDecode + StaticGraphViewOps + AdditionOps {
-    fn decode(path: impl Into<GraphFolder>) -> Result<Self, GraphError> {
-        let folder = path.into();
-        let graph = Self::decode_from_path(&folder)?;
+        let folder: GraphFolder = path.into();
 
-        #[cfg(feature = "search")]
-        graph.load_index(&folder)?;
-
-        Ok(graph)
+        if folder.write_as_zip_format {
+            let file = File::create_new(folder.root())?;
+            self.encode_to_zip(ZipWriter::new(file))?;
+        } else {
+            let write_folder = folder.init_write()?;
+            self.encode_parquet(write_folder.graph_path()?)?;
+            #[cfg(feature = "search")]
+            self.persist_index_to_disk(&write_folder)?;
+            write_folder.data_path()?.write_metadata(self)?;
+            write_folder.finish()?;
+        }
+        Ok(())
     }
 }
 
-impl<T: InternalStableDecode + StaticGraphViewOps + AdditionOps> StableDecode for T {}
-
-pub trait InternalStableDecode: Sized {
-    fn decode_from_proto(graph: &proto::Graph) -> Result<Self, GraphError>;
+pub trait StableDecode: StaticGraphViewOps + AdditionOps {
+    // Decode the graph from the given bytes array.
+    // `path_for_decoded_graph` gets passed to the newly created graph.
+    fn decode_from_bytes_with_config(bytes: &[u8], config: Config) -> Result<Self, GraphError>;
 
     fn decode_from_bytes(bytes: &[u8]) -> Result<Self, GraphError> {
-        let graph = proto::Graph::decode(bytes)?;
-        Self::decode_from_proto(&graph)
+        Self::decode_from_bytes_with_config(bytes, Config::default())
     }
 
-    fn decode_from_path(path: &GraphFolder) -> Result<Self, GraphError> {
-        let bytes = path.read_graph()?;
-        let graph = Self::decode_from_bytes(bytes.as_ref())?;
-        Ok(graph)
-    }
-}
-
-pub trait CacheOps: Sized {
-    /// Write graph to file and append future updates to the same file.
-    ///
-    /// If the file already exists, it's contents are overwritten
-    fn cache(&self, path: impl Into<GraphFolder>) -> Result<(), GraphError>;
-
-    /// Persist the new updates by appending them to the cache file.
-    fn write_updates(&self) -> Result<(), GraphError>;
-
-    /// Load graph from file and append future updates to the same file
-    fn load_cached(path: impl Into<GraphFolder>) -> Result<Self, GraphError>;
-}
-
-impl StableEncode for GraphStorage {
-    fn encode_to_proto(&self) -> proto::Graph {
-        let storage = self.lock();
-        let mut graph = proto::Graph::default();
-
-        // Graph Properties
-        let graph_meta = storage.graph_meta();
-        for (id, key) in graph_meta.metadata_mapper().get_keys().iter().enumerate() {
-            graph.new_graph_cprop(key, id);
-        }
-        graph.update_graph_cprops(graph_meta.metadata());
-
-        for (id, (key, dtype)) in graph_meta
-            .temporal_mapper()
-            .get_keys()
-            .iter()
-            .zip(graph_meta.temporal_mapper().dtypes().iter())
-            .enumerate()
-        {
-            graph.new_graph_tprop(key, id, dtype);
-        }
-        for (t, group) in &graph_meta
-            .temporal_props()
-            .map(|(key, values)| {
-                values
-                    .deref()
-                    .iter()
-                    .map(move |(t, v)| (t, (key, v)))
-                    .collect::<Vec<_>>()
-            })
-            .kmerge_by(|(left_t, _), (right_t, _)| left_t <= right_t)
-            .chunk_by(|(t, _)| *t)
-        {
-            graph.update_graph_tprops(t, group.map(|(_, v)| v));
-        }
-
-        // Layers
-        for (id, layer) in storage
-            .edge_meta()
-            .layer_meta()
-            .get_keys()
-            .iter()
-            .enumerate()
-        {
-            graph.new_layer(layer, id);
-        }
-
-        // Node Types
-        for (id, node_type) in storage
-            .node_meta()
-            .node_type_meta()
-            .get_keys()
-            .iter()
-            .enumerate()
-        {
-            graph.new_node_type(node_type, id);
-        }
-
-        // Node Properties
-        let n_const_meta = self.node_meta().metadata_mapper();
-        for (id, (key, dtype)) in n_const_meta
-            .get_keys()
-            .iter()
-            .zip(n_const_meta.dtypes().iter())
-            .enumerate()
-        {
-            graph.new_node_cprop(key, id, dtype);
-        }
-        let n_temporal_meta = self.node_meta().temporal_prop_mapper();
-        for (id, (key, dtype)) in n_temporal_meta
-            .get_keys()
-            .iter()
-            .zip(n_temporal_meta.dtypes().iter())
-            .enumerate()
-        {
-            graph.new_node_tprop(key, id, dtype);
-        }
-
-        // Nodes
-        let nodes = storage.nodes();
-        for node_id in 0..nodes.len() {
-            let node = nodes.node(VID(node_id));
-            graph.new_node(node.id(), node.vid(), node.node_type_id());
-
-            for (time, row) in node.temp_prop_rows() {
-                graph.update_node_tprops(
-                    node.vid(),
-                    time,
-                    row.into_iter().filter_map(|(id, prop)| Some((id, prop?))),
-                );
-            }
-
-            graph.update_node_cprops(
-                node.vid(),
-                (0..n_const_meta.len()).flat_map(|i| node.prop(i).map(|v| (i, v))),
-            );
-        }
+    fn decode_from_bytes_at(
+        bytes: &[u8],
+        target: &(impl GraphPaths + ?Sized),
+        config: Config,
+    ) -> Result<Self, GraphError>;
 
-        // Edge Properties
-        let e_const_meta = self.edge_meta().metadata_mapper();
-        for (id, (key, dtype)) in e_const_meta
-            .get_keys()
-            .iter()
-            .zip(e_const_meta.dtypes().iter())
-            .enumerate()
-        {
-            graph.new_edge_cprop(key, id, dtype);
-        }
-        let e_temporal_meta = self.edge_meta().temporal_prop_mapper();
-        for (id, (key, dtype)) in e_temporal_meta
-            .get_keys()
-            .iter()
-            .zip(e_temporal_meta.dtypes().iter())
-            .enumerate()
-        {
-            graph.new_edge_tprop(key, id, dtype);
-        }
+    fn decode_from_zip_with_config<R: Read + Seek>(
+        reader: ZipArchive<R>,
+        config: Config,
+    ) -> Result<Self, GraphError>;
 
-        // Edges
-        let edges = storage.edges();
-        for eid in 0..edges.len() {
-            let eid = EID(eid);
-            let edge = edges.edge(eid);
-            let edge = edge.as_ref();
-            graph.new_edge(edge.src(), edge.dst(), eid);
-            for layer_id in 0..storage.unfiltered_num_layers() {
-                for (t, props) in
-                    zip_tprop_updates!((0..e_temporal_meta.len())
-                        .map(|i| (i, edge.temporal_prop_layer(layer_id, i))))
-                {
-                    graph.update_edge_tprops(eid, t, layer_id, props.map(|(_, v)| v));
-                }
-                for t in edge.additions(layer_id).iter() {
-                    graph.update_edge_tprops(eid, t, layer_id, iter::empty::<(usize, Prop)>());
-                }
-                for t in edge.deletions(layer_id).iter() {
-                    graph.del_edge(eid, layer_id, t);
-                }
-                graph.update_edge_cprops(
-                    eid,
-                    layer_id,
-                    (0..e_const_meta.len())
-                        .filter_map(|i| edge.metadata_layer(layer_id, i).map(|prop| (i, prop))),
-                );
-            }
-        }
-        graph
+    fn decode_from_zip<R: Read + Seek>(reader: ZipArchive<R>) -> Result<Self, GraphError> {
+        Self::decode_from_zip_with_config(reader, Config::default())
     }
-}
 
-impl StableEncode for Graph {
-    fn encode_to_proto(&self) -> proto::Graph {
-        let mut graph = self.core_graph().encode_to_proto();
-        graph.set_graph_type(proto::GraphType::Event);
-        graph
-    }
-}
-
-impl StableEncode for PersistentGraph {
-    fn encode_to_proto(&self) -> proto::Graph {
-        let mut graph = self.core_graph().encode_to_proto();
-        graph.set_graph_type(proto::GraphType::Persistent);
-        graph
-    }
-}
+    fn decode_from_zip_at<R: Read + Seek>(
+        reader: ZipArchive<R>,
+        target: &(impl GraphPaths + ?Sized),
+        config: Config,
+    ) -> Result<Self, GraphError>;
 
-impl StableEncode for MaterializedGraph {
-    fn encode_to_proto(&self) -> proto::Graph {
-        match self {
-            MaterializedGraph::EventGraph(graph) => graph.encode_to_proto(),
-            MaterializedGraph::PersistentGraph(graph) => graph.encode_to_proto(),
-        }
+    // Decode the graph from the given path.
+    // `path_for_decoded_graph` gets passed to the newly created graph.
+    fn decode(path: &(impl GraphPaths + ?Sized)) -> Result<Self, GraphError> {
+        Self::decode_with_config(path, Config::default())
     }
-}
-
-impl InternalStableDecode for TemporalGraph {
-    fn decode_from_proto(graph: &proto::Graph) -> Result<Self, GraphError> {
-        let storage = Self::default();
-        graph.metas.par_iter().for_each(|meta| {
-            if let Some(meta) = meta.meta.as_ref() {
-                match meta {
-                    Meta::NewNodeType(node_type) => {
-                        storage
-                            .node_meta
-                            .node_type_meta()
-                            .set_id(node_type.name.as_str(), node_type.id as usize);
-                    }
-                    Meta::NewNodeCprop(node_cprop) => {
-                        let p_type = node_cprop.prop_type();
-                        storage.node_meta.metadata_mapper().set_id_and_dtype(
-                            node_cprop.name.as_str(),
-                            node_cprop.id as usize,
-                            p_type,
-                        )
-                    }
-                    Meta::NewNodeTprop(node_tprop) => {
-                        let p_type = node_tprop.prop_type();
-                        storage.node_meta.temporal_prop_mapper().set_id_and_dtype(
-                            node_tprop.name.as_str(),
-                            node_tprop.id as usize,
-                            p_type,
-                        )
-                    }
-                    Meta::NewGraphCprop(graph_cprop) => storage
-                        .graph_meta
-                        .metadata_mapper()
-                        .set_id(graph_cprop.name.as_str(), graph_cprop.id as usize),
-                    Meta::NewGraphTprop(graph_tprop) => {
-                        let p_type = graph_tprop.prop_type();
-                        storage.graph_meta.temporal_mapper().set_id_and_dtype(
-                            graph_tprop.name.as_str(),
-                            graph_tprop.id as usize,
-                            p_type,
-                        )
-                    }
-                    Meta::NewLayer(new_layer) => storage
-                        .edge_meta
-                        .layer_meta()
-                        .set_id(new_layer.name.as_str(), new_layer.id as usize),
-                    Meta::NewEdgeCprop(edge_cprop) => {
-                        let p_type = edge_cprop.prop_type();
-                        storage.edge_meta.metadata_mapper().set_id_and_dtype(
-                            edge_cprop.name.as_str(),
-                            edge_cprop.id as usize,
-                            p_type,
-                        )
-                    }
-                    Meta::NewEdgeTprop(edge_tprop) => {
-                        let p_type = edge_tprop.prop_type();
-                        storage.edge_meta.temporal_prop_mapper().set_id_and_dtype(
-                            edge_tprop.name.as_str(),
-                            edge_tprop.id as usize,
-                            p_type,
-                        )
-                    }
-                }
-            }
-        });
-
-        let new_edge_property_types = storage
-            .write_lock_edges()?
-            .into_par_iter_mut()
-            .map(|mut shard| {
-                let mut metadata_types =
-                    vec![PropType::Empty; storage.edge_meta.metadata_mapper().len()];
-                let mut temporal_prop_types =
-                    vec![PropType::Empty; storage.edge_meta.temporal_prop_mapper().len()];
-
-                for edge in graph.edges.iter() {
-                    if let Some(mut new_edge) = shard.get_mut(edge.eid()) {
-                        let edge_store = new_edge.edge_store_mut();
-                        edge_store.src = edge.src();
-                        edge_store.dst = edge.dst();
-                        edge_store.eid = edge.eid();
-                    }
-                }
-                for update in graph.updates.iter() {
-                    if let Some(update) = update.update.as_ref() {
-                        match update {
-                            Update::DelEdge(del_edge) => {
-                                if let Some(mut edge_mut) = shard.get_mut(del_edge.eid()) {
-                                    edge_mut
-                                        .deletions_mut(del_edge.layer_id())
-                                        .insert(del_edge.time());
-                                    storage.update_time(del_edge.time());
-                                }
-                            }
-                            Update::UpdateEdgeCprops(update) => {
-                                if let Some(mut edge_mut) = shard.get_mut(update.eid()) {
-                                    let edge_layer = edge_mut.layer_mut(update.layer_id());
-                                    for prop_update in update.props() {
-                                        let (id, prop) = prop_update?;
-                                        let prop = storage.process_prop_value(&prop);
-                                        if let Ok(new_type) = unify_types(
-                                            &metadata_types[id],
-                                            &prop.dtype(),
-                                            &mut false,
-                                        ) {
-                                            metadata_types[id] = new_type; // the original types saved in protos are now incomplete we need to update them
-                                        }
-                                        edge_layer.update_metadata(id, prop)?;
-                                    }
-                                }
-                            }
-                            Update::UpdateEdgeTprops(update) => {
-                                if let Some(mut edge_mut) = shard.get_mut(update.eid()) {
-                                    edge_mut
-                                        .additions_mut(update.layer_id())
-                                        .insert(update.time());
-                                    if update.has_props() {
-                                        let edge_layer = edge_mut.layer_mut(update.layer_id());
-                                        for prop_update in update.props() {
-                                            let (id, prop) = prop_update?;
-                                            let prop = storage.process_prop_value(&prop);
-                                            if let Ok(new_type) = unify_types(
-                                                &temporal_prop_types[id],
-                                                &prop.dtype(),
-                                                &mut false,
-                                            ) {
-                                                temporal_prop_types[id] = new_type;
-                                                // the original types saved in protos are now incomplete we need to update them
-                                            }
-                                            edge_layer.add_prop(update.time(), id, prop)?;
-                                        }
-                                    }
-                                    storage.update_time(update.time())
-                                }
-                            }
-                            _ => {}
-                        }
-                    }
-                }
-                Ok::<_, GraphError>((metadata_types, temporal_prop_types))
-            })
-            .try_reduce_with(|(l_const, l_temp), (r_const, r_temp)| {
-                unify_property_types(&l_const, &r_const, &l_temp, &r_temp)
-            })
-            .transpose()?;
-
-        if let Some((metadata_types, temp_prop_types)) = new_edge_property_types {
-            update_meta(
-                metadata_types,
-                temp_prop_types,
-                storage.edge_meta.metadata_mapper(),
-                storage.edge_meta.temporal_prop_mapper(),
-            );
-        }
-
-        let new_nodes_property_types = storage
-            .write_lock_nodes()?
-            .into_par_iter_mut()
-            .map(|mut shard| {
-                let mut metadata_types =
-                    vec![PropType::Empty; storage.node_meta.metadata_mapper().len()];
-                let mut temporal_prop_types =
-                    vec![PropType::Empty; storage.node_meta.temporal_prop_mapper().len()];
 
-                for node in graph.nodes.iter() {
-                    let vid = VID(node.vid as usize);
-                    let gid = match node.gid.as_ref().unwrap() {
-                        Gid::GidStr(name) => GidRef::Str(name),
-                        Gid::GidU64(gid) => GidRef::U64(*gid),
-                    };
-                    if let Some(mut node_store) = shard.set(vid, gid) {
-                        storage.logical_to_physical.set(gid, vid)?;
-                        node_store.node_store_mut().node_type = node.type_id as usize;
-                    }
-                }
-                let edges = storage.storage.edges.read_lock();
-                for edge in edges.iter() {
-                    if let Some(src) = shard.get_mut(edge.src()) {
-                        for layer in edge.layer_ids_iter(&LayerIds::All) {
-                            src.add_edge(edge.dst(), Direction::OUT, layer, edge.eid());
-                            for t in edge.additions(layer).iter() {
-                                src.update_time(t, edge.eid().with_layer(layer));
-                            }
-                            for t in edge.deletions(layer).iter() {
-                                src.update_time(t, edge.eid().with_layer_deletion(layer));
-                            }
-                        }
-                    }
-                    if let Some(dst) = shard.get_mut(edge.dst()) {
-                        for layer in edge.layer_ids_iter(&LayerIds::All) {
-                            dst.add_edge(edge.src(), Direction::IN, layer, edge.eid());
-                            for t in edge.additions(layer).iter() {
-                                dst.update_time(t, edge.eid().with_layer(layer));
-                            }
-                            for t in edge.deletions(layer).iter() {
-                                dst.update_time(t, edge.eid().with_layer_deletion(layer));
-                            }
-                        }
-                    }
-                }
-                for update in graph.updates.iter() {
-                    if let Some(update) = update.update.as_ref() {
-                        match update {
-                            Update::UpdateNodeCprops(update) => {
-                                if let Some(node) = shard.get_mut(update.vid()) {
-                                    for prop_update in update.props() {
-                                        let (id, prop) = prop_update?;
-                                        let prop = storage.process_prop_value(&prop);
-                                        if let Ok(new_type) = unify_types(
-                                            &metadata_types[id],
-                                            &prop.dtype(),
-                                            &mut false,
-                                        ) {
-                                            metadata_types[id] = new_type; // the original types saved in protos are now incomplete we need to update them
-                                        }
-                                        node.update_metadata(id, prop)?;
-                                    }
-                                }
-                            }
-                            Update::UpdateNodeTprops(update) => {
-                                if let Some(mut node) = shard.get_mut_entry(update.vid()) {
-                                    let mut props = vec![];
-                                    for prop_update in update.props() {
-                                        let (id, prop) = prop_update?;
-                                        let prop = storage.process_prop_value(&prop);
-                                        if let Ok(new_type) = unify_types(
-                                            &temporal_prop_types[id],
-                                            &prop.dtype(),
-                                            &mut false,
-                                        ) {
-                                            temporal_prop_types[id] = new_type; // the original types saved in protos are now incomplete we need to update them
-                                        }
-                                        props.push((id, prop));
-                                    }
+    fn decode_with_config(
+        path: &(impl GraphPaths + ?Sized),
+        config: Config,
+    ) -> Result<Self, GraphError>;
 
-                                    if props.is_empty() {
-                                        node.node_store_mut()
-                                            .update_t_prop_time(update.time(), None);
-                                    } else {
-                                        let prop_offset = node.t_props_log_mut().push(props)?;
-                                        node.node_store_mut()
-                                            .update_t_prop_time(update.time(), prop_offset);
-                                    }
-
-                                    storage.update_time(update.time())
-                                }
-                            }
-                            Update::UpdateNodeType(update) => {
-                                if let Some(node) = shard.get_mut(update.vid()) {
-                                    node.node_type = update.type_id();
-                                }
-                            }
-                            _ => {}
-                        }
-                    }
-                }
-                Ok::<_, GraphError>((metadata_types, temporal_prop_types))
-            })
-            .try_reduce_with(|(l_const, l_temp), (r_const, r_temp)| {
-                unify_property_types(&l_const, &r_const, &l_temp, &r_temp)
-            })
-            .transpose()?;
-
-        if let Some((metadata_types, temp_prop_types)) = new_nodes_property_types {
-            update_meta(
-                metadata_types,
-                temp_prop_types,
-                storage.node_meta.metadata_mapper(),
-                storage.node_meta.temporal_prop_mapper(),
-            );
-        }
-
-        let graph_prop_new_types = graph
-            .updates
-            .par_iter()
-            .map(|update| {
-                let mut metadata_types =
-                    vec![PropType::Empty; storage.graph_meta.metadata_mapper().len()];
-                let mut graph_prop_types =
-                    vec![PropType::Empty; storage.graph_meta.temporal_mapper().len()];
-
-                if let Some(update) = update.update.as_ref() {
-                    match update {
-                        Update::UpdateGraphCprops(props) => {
-                            let c_props = proto_ext::collect_props(&props.properties)?;
-                            for (id, prop) in &c_props {
-                                metadata_types[*id] = prop.dtype();
-                            }
-                            storage.internal_update_metadata(&c_props)?;
-                        }
-                        Update::UpdateGraphTprops(props) => {
-                            let time = EventTime(props.time, props.secondary as usize);
-                            let t_props = proto_ext::collect_props(&props.properties)?;
-                            for (id, prop) in &t_props {
-                                graph_prop_types[*id] = prop.dtype();
-                            }
-                            storage.internal_add_properties(time, &t_props)?;
-                        }
-                        _ => {}
-                    }
-                }
-                Ok::<_, GraphError>((metadata_types, graph_prop_types))
-            })
-            .try_reduce_with(|(l_const, l_temp), (r_const, r_temp)| {
-                unify_property_types(&l_const, &r_const, &l_temp, &r_temp)
-            })
-            .transpose()?;
-
-        if let Some((metadata_types, temp_prop_types)) = graph_prop_new_types {
-            update_meta(
-                metadata_types,
-                temp_prop_types,
-                &PropMapper::default(),
-                storage.graph_meta.temporal_mapper(),
-            );
-        }
-        Ok(storage)
-    }
+    fn decode_at(
+        path: &(impl GraphPaths + ?Sized),
+        target: &(impl GraphPaths + ?Sized),
+        config: Config,
+    ) -> Result<Self, GraphError>;
 }
 
-fn update_meta(
-    metadata_types: Vec<PropType>,
-    temp_prop_types: Vec<PropType>,
-    const_meta: &PropMapper,
-    temp_meta: &PropMapper,
-) {
-    let keys = { const_meta.get_keys().iter().cloned().collect::<Vec<_>>() };
-    for ((id, prop_type), key) in metadata_types.into_iter().enumerate().zip(keys) {
-        const_meta.set_id_and_dtype(key, id, prop_type);
+impl<T: ParquetDecoder + StaticGraphViewOps + AdditionOps> StableDecode for T {
+    fn decode_from_bytes_with_config(bytes: &[u8], config: Config) -> Result<Self, GraphError> {
+        let cursor = Cursor::new(bytes);
+        Self::decode_from_zip_with_config(ZipArchive::new(cursor)?, config)
     }
-    let keys = { temp_meta.get_keys().iter().cloned().collect::<Vec<_>>() };
 
-    for ((id, prop_type), key) in temp_prop_types.into_iter().enumerate().zip(keys) {
-        temp_meta.set_id_and_dtype(key, id, prop_type);
+    fn decode_from_bytes_at(
+        bytes: &[u8],
+        target: &(impl GraphPaths + ?Sized),
+        config: Config,
+    ) -> Result<Self, GraphError> {
+        let cursor = Cursor::new(bytes);
+        Self::decode_from_zip_at(ZipArchive::new(cursor)?, target, config)
     }
-}
 
-fn unify_property_types(
-    l_const: &[PropType],
-    r_const: &[PropType],
-    l_temp: &[PropType],
-    r_temp: &[PropType],
-) -> Result<(Vec<PropType>, Vec<PropType>), GraphError> {
-    let const_pt = l_const
-        .iter()
-        .zip(r_const)
-        .map(|(l, r)| unify_types(l, r, &mut false))
-        .collect::<Result<Vec<PropType>, _>>()?;
-    let temp_pt = l_temp
-        .iter()
-        .zip(r_temp)
-        .map(|(l, r)| unify_types(l, r, &mut false))
-        .collect::<Result<Vec<PropType>, _>>()?;
-    Ok((const_pt, temp_pt))
-}
+    fn decode_from_zip_with_config<R: Read + Seek>(
+        mut reader: ZipArchive<R>,
+        config: Config,
+    ) -> Result<Self, GraphError> {
+        let graph_prefix = get_zip_graph_path(&mut reader)?;
+        let graph = Self::decode_parquet_from_zip(&mut reader, None, graph_prefix, config)?;
 
-impl InternalStableDecode for GraphStorage {
-    fn decode_from_proto(graph: &proto::Graph) -> Result<Self, GraphError> {
-        Ok(GraphStorage::Unlocked(Arc::new(
-            TemporalGraph::decode_from_proto(graph)?,
-        )))
-    }
-}
+        //TODO: graph.load_index_from_zip(&mut reader, prefix)
 
-impl InternalStableDecode for MaterializedGraph {
-    fn decode_from_proto(graph: &proto::Graph) -> Result<Self, GraphError> {
-        let storage = GraphStorage::decode_from_proto(graph)?;
-        let graph = match graph.graph_type() {
-            proto::GraphType::Event => Self::EventGraph(Graph::from_internal_graph(storage)),
-            proto::GraphType::Persistent => {
-                Self::PersistentGraph(PersistentGraph::from_internal_graph(storage))
-            }
-        };
         Ok(graph)
     }
-}
 
-impl InternalStableDecode for Graph {
-    fn decode_from_proto(graph: &proto::Graph) -> Result<Self, GraphError> {
-        match graph.graph_type() {
-            proto::GraphType::Event => {
-                let storage = GraphStorage::decode_from_proto(graph)?;
-                Ok(Graph::from_internal_graph(storage))
-            }
-            proto::GraphType::Persistent => Err(GraphError::GraphLoadError),
-        }
+    fn decode_from_zip_at<R: Read + Seek>(
+        mut reader: ZipArchive<R>,
+        target: &(impl GraphPaths + ?Sized),
+        config: Config,
+    ) -> Result<Self, GraphError> {
+        if !Extension::disk_storage_enabled() {
+            return Err(GraphError::DiskGraphNotEnabled);
+        }
+        target.init()?;
+        let graph_prefix = get_zip_graph_path(&mut reader)?;
+        let graph = Self::decode_parquet_from_zip(
+            &mut reader,
+            Some(target.graph_path()?.as_path()),
+            graph_prefix,
+            config,
+        )?;
+
+        //TODO: graph.load_index_from_zip(&mut reader, prefix)
+        target.write_metadata(&graph)?;
+        Ok(graph)
     }
-}
 
-impl InternalStableDecode for PersistentGraph {
-    fn decode_from_proto(graph: &proto::Graph) -> Result<Self, GraphError> {
-        match graph.graph_type() {
-            proto::GraphType::Event => Err(GraphError::GraphLoadError),
-            proto::GraphType::Persistent => {
-                let storage = GraphStorage::decode_from_proto(graph)?;
-                Ok(PersistentGraph::from_internal_graph(storage))
-            }
-        }
+    fn decode_with_config(
+        path: &(impl GraphPaths + ?Sized),
+        config: Config,
+    ) -> Result<Self, GraphError> {
+        if path.is_zip() {
+            let reader = path.read_zip()?;
+            Self::decode_from_zip_with_config(reader, config)
+        } else {
+            Self::decode_parquet(&path.graph_path()?, None, config)
+            // TODO: Fix index loading:
+            // #[cfg(feature = "search")]
+            // graph.load_index(&path)?;
+        }
+    }
+
+    fn decode_at(
+        path: &(impl GraphPaths + ?Sized),
+        target: &(impl GraphPaths + ?Sized),
+        config: Config,
+    ) -> Result<Self, GraphError> {
+        target.init()?;
+        let graph;
+        if path.is_zip() {
+            let reader = path.read_zip()?;
+            graph = Self::decode_from_zip_at(reader, target, config)?;
+        } else {
+            graph = Self::decode_parquet(
+                path.graph_path()?,
+                Some(target.graph_path()?.as_path()),
+                config,
+            )?;
+        }
+        target.write_metadata(&graph)?;
+        Ok(graph)
     }
 }
diff --git a/raphtory/src/test_utils.rs b/raphtory/src/test_utils.rs
index 1a5fea9ded..a2df97d642 100644
--- a/raphtory/src/test_utils.rs
+++ b/raphtory/src/test_utils.rs
@@ -1,34 +1,414 @@
-use crate::{db::api::storage::storage::Storage, prelude::*};
+use crate::{
+    db::{
+        api::storage::storage::Storage,
+        graph::{edge::EdgeView, node::NodeView},
+    },
+    prelude::*,
+};
 use ahash::HashSet;
 use bigdecimal::BigDecimal;
 use chrono::{DateTime, NaiveDateTime, Utc};
 use itertools::Itertools;
 use proptest::{arbitrary::any, prelude::*};
 use proptest_derive::Arbitrary;
-use raphtory_api::core::entities::properties::prop::{PropType, DECIMAL_MAX};
-use raphtory_storage::{core_ops::CoreGraphOps, mutation::addition_ops::InternalAdditionOps};
-use std::{collections::HashMap, sync::Arc};
+use rand::seq::SliceRandom;
+use raphtory_api::core::{
+    entities::properties::prop::{PropType, DECIMAL_MAX},
+    storage::{
+        arc_str::{ArcStr, OptionAsStr},
+        timeindex::AsTime,
+    },
+};
+use raphtory_storage::{
+    core_ops::CoreGraphOps,
+    mutation::addition_ops::{InternalAdditionOps, SessionAdditionOps},
+};
+use rayon::iter::ParallelIterator;
+use serde::{
+    de::{SeqAccess, Visitor},
+    ser::SerializeSeq,
+    Deserialize, Deserializer, Serialize, Serializer,
+};
+use serde_json::Value;
+use std::{
+    borrow::Cow,
+    collections::{hash_map, HashMap},
+    fmt::{Debug, Formatter},
+    mem,
+    ops::{Deref, RangeInclusive},
+    sync::Arc,
+};
 
-#[cfg(feature = "storage")]
-use tempfile::TempDir;
+#[derive(PartialEq, Eq, PartialOrd, Ord)]
+pub enum NameSortKey<'a> {
+    Node(&'a str),
+    Edge(&'a str, &'a str),
+}
 
-#[cfg(feature = "storage")]
-pub fn test_disk_graph(graph: &Graph, test: impl FnOnce(&Graph)) {
-    let test_dir = TempDir::new().unwrap();
-    let disk_graph = graph.persist_as_disk_graph(test_dir.path()).unwrap();
-    test(&disk_graph)
+fn name_sort_key(value: &Value) -> Option<NameSortKey<'_>> {
+    match value {
+        Value::Object(inner) => inner
+            .get("name")
+            .and_then(|name| Some(NameSortKey::Node(name.as_str()?)))
+            .or_else(|| {
+                inner.get("id").and_then(|id| match id {
+                    Value::String(node) => Some(NameSortKey::Node(node)),
+                    Value::Array(edge) => {
+                        let (src, dst) = edge.iter().map(|e| e.as_str().unwrap()).next_tuple()?;
+                        Some(NameSortKey::Edge(src, dst))
+                    }
+                    _ => None,
+                })
+            }),
+        _ => None,
+    }
+}
+
+pub fn json_sort_by_name(value: Value) -> Value {
+    match value {
+        Value::Array(inner) => Value::Array(
+            inner
+                .into_iter()
+                .sorted_by(|l, r| name_sort_key(l).cmp(&name_sort_key(r)))
+                .map(|inner_value| json_sort_by_name(inner_value))
+                .collect(),
+        ),
+        Value::Object(inner) => Value::Object(
+            inner
+                .into_iter()
+                .map(|(key, value)| (key, json_sort_by_name(value)))
+                .collect(),
+        ),
+        value => value,
+    }
 }
 
 pub fn test_graph(graph: &Graph, test: impl FnOnce(&Graph)) {
     test(graph)
 }
 
+pub fn assert_valid_graph(fixture: &GraphFixture, graph: &Graph) {
+    // helpers for extracting data from fixtures
+    let get_fixture_metadata_map = |c_props: &Vec<(String, Prop)>| -> HashMap<ArcStr, Prop> {
+        c_props
+            .iter()
+            .map(|(k, v)| (ArcStr::from(k.as_str()), v.clone()))
+            .collect()
+    };
+
+    // compare histories as multiset as order for values with the same timestamp is ambiguous!
+    let get_fixture_t_prop_counts =
+        |t_props: &Vec<(i64, Vec<(String, Prop)>)>| -> HashMap<ArcStr, Vec<(i64, HashMap<Prop, usize>)>> {
+            let mut grouped: HashMap<ArcStr, HashMap<i64, HashMap<Prop, usize>>> = HashMap::new();
+            for (t, props) in t_props {
+                for (k, v) in props {
+                    grouped.entry(ArcStr::from(k.as_str()))
+                        .or_default().entry(*t).or_default().entry(v.clone()).and_modify(|v| *v += 1).or_insert(1);
+                }
+            }
+            grouped.into_iter().map(|(key, value)| (key, value.into_iter().sorted_by_key(|(t, _)| *t).collect())).collect()
+        };
+
+    let get_node_t_prop_map =
+        |node: &NodeView<&Graph>| -> HashMap<ArcStr, Vec<(i64, HashMap<Prop, usize>)>> {
+            let out: HashMap<ArcStr, Vec<(i64, HashMap<Prop, usize>)>> = node
+                .properties()
+                .temporal()
+                .iter()
+                .filter(|(_, props)| !props.is_empty())
+                .map(|(key, values)| {
+                    let runs = values
+                        .iter()
+                        .map(|(t, v)| (t, HashMap::from([(v, 1usize)])))
+                        .coalesce(|(lt, mut lv), (rt, rv)| {
+                            if lt.t() == rt.t() {
+                                for (v, count) in rv {
+                                    lv.entry(v).and_modify(|c| *c += count).or_insert(count);
+                                }
+                                Ok((lt, lv))
+                            } else {
+                                Err(((lt, lv), (rt, rv)))
+                            }
+                        })
+                        .map(|(t, v)| (t.t(), v))
+                        .collect();
+                    (key, runs)
+                })
+                .collect();
+            out
+        };
+    let get_edge_t_prop_counts =
+        |edge: &EdgeView<&Graph>| -> HashMap<ArcStr, Vec<(i64, HashMap<Prop, usize>)>> {
+            let out: HashMap<ArcStr, Vec<(i64, HashMap<Prop, usize>)>> = edge
+                .properties()
+                .temporal()
+                .iter()
+                .filter(|(_, props)| !props.is_empty())
+                .map(|(key, values)| {
+                    let runs = values
+                        .iter()
+                        .map(|(t, v)| (t, HashMap::from([(v, 1usize)])))
+                        .coalesce(|(lt, mut lv), (rt, rv)| {
+                            if lt.t() == rt.t() {
+                                for (v, count) in rv {
+                                    lv.entry(v).and_modify(|c| *c += count).or_insert(count);
+                                }
+                                Ok((lt, lv))
+                            } else {
+                                Err(((lt, lv), (rt, rv)))
+                            }
+                        })
+                        .map(|(t, v)| (t.t(), v))
+                        .collect();
+                    (key, runs)
+                })
+                .collect();
+            out
+        };
+
+    // collect expected sets from fixture
+    let mut expected_node_histories: HashMap<u64, Vec<i64>> = fixture
+        .nodes()
+        .map(|(n, updates)| {
+            (
+                n,
+                updates.props.t_props.iter().map(|(t, _)| *t).collect_vec(),
+            )
+        })
+        .filter(|(_, hist)| !hist.is_empty())
+        .collect();
+    for ((src, dst, _), updates) in fixture.edges() {
+        expected_node_histories
+            .entry(src)
+            .or_default()
+            .extend(updates.props.t_props.iter().map(|(t, _)| *t));
+        if src != dst {
+            expected_node_histories
+                .entry(dst)
+                .or_default()
+                .extend(updates.props.t_props.iter().map(|(t, _)| *t));
+        }
+        // deletions are part of history as well
+        expected_node_histories
+            .entry(src)
+            .or_default()
+            .extend(updates.deletions.iter().copied());
+        if src != dst {
+            expected_node_histories
+                .entry(dst)
+                .or_default()
+                .extend(updates.deletions.iter().copied());
+        }
+    }
+    // sort history vecs to match node.history()
+    for values in expected_node_histories.values_mut() {
+        values.sort();
+    }
+    let expected_edge_pairs: std::collections::HashSet<(u64, u64)> = fixture
+        .edges()
+        .map(|((src, dst, _), _)| (src, dst))
+        .collect();
+    let expected_exploded_edge_count: usize = fixture
+        .edges()
+        .map(|(_, updates)| updates.props.t_props.len())
+        .sum();
+    let expected_edge_layer_updates: HashMap<(u64, u64, ArcStr), _> = fixture
+        .edges()
+        .map(|((s, d, layer), updates)| {
+            ((s, d, ArcStr::from(layer.unwrap_or("_default"))), updates)
+        })
+        .collect();
+
+    // graph-level checks
+    let expected_node_ids: std::collections::HashSet<u64> = expected_node_histories
+        .keys()
+        .copied()
+        .collect::<std::collections::HashSet<u64>>();
+    let actual_node_ids: std::collections::HashSet<u64> = graph
+        .nodes()
+        .id()
+        .par_iter_values()
+        .map(|x| {
+            x.as_u64()
+                .unwrap_or_else(|| panic!("u64 could not be retrieved from GID: {x:?}"))
+        })
+        .collect();
+    assert_eq!(
+        expected_node_ids, actual_node_ids,
+        "mismatched node id set: expected {:?}, got {:?}",
+        expected_node_ids, actual_node_ids
+    );
+
+    for ((_, _, layer), _) in &expected_edge_layer_updates {
+        assert!(
+            graph.has_layer(layer.as_ref()),
+            "graph missing expected layer {:?}",
+            layer
+        );
+    }
+
+    // check earliest/latest time
+    let mut all_times: Vec<i64> = Vec::new();
+    for (_, updates) in fixture.nodes() {
+        all_times.extend(updates.props.t_props.iter().map(|(t, _)| *t));
+    }
+    for (_, updates) in fixture.edges() {
+        all_times.extend(updates.props.t_props.iter().map(|(t, _)| *t));
+        all_times.extend(updates.deletions.iter().copied());
+    }
+
+    if all_times.is_empty() {
+        assert!(graph.earliest_time().is_none(), "expected no earliest_time");
+        assert!(graph.latest_time().is_none(), "expected no latest_time");
+    } else {
+        let expected_earliest = *all_times.iter().min().unwrap();
+        let expected_latest = *all_times.iter().max().unwrap();
+        assert_eq!(
+            graph.earliest_time().map(|t| t.t()),
+            Some(expected_earliest),
+            "mismatched earliest_time"
+        );
+        assert_eq!(
+            graph.latest_time().map(|t| t.t()),
+            Some(expected_latest),
+            "mismatched latest_time"
+        );
+    }
+
+    // node-level checks
+    for (node_id, expected_history) in expected_node_histories {
+        let node = (&graph)
+            .node(node_id)
+            .unwrap_or_else(|| panic!("graph should have node {node_id}"));
+        assert_eq!(
+            expected_history,
+            node.history().t().iter().collect_vec(),
+            "mismatched history for node {node_id}"
+        );
+
+        match fixture.nodes.0.get(&node_id) {
+            Some(updates) => {
+                assert_eq!(
+                    node.node_type().as_str(),
+                    updates.node_type.as_str(),
+                    "mismatched node_type for node {node_id}"
+                );
+
+                let expected_metadata = get_fixture_metadata_map(&updates.props.c_props);
+                assert_eq!(
+                    node.metadata().as_map(),
+                    expected_metadata,
+                    "mismatched node metadata for node {node_id}"
+                );
+
+                let expected_temporal = get_fixture_t_prop_counts(&updates.props.t_props);
+                let actual_temporal = get_node_t_prop_map(&node);
+                assert_eq!(
+                    actual_temporal, expected_temporal,
+                    "mismatched node temporal properties for node {node_id}"
+                );
+            }
+            None => {
+                // node exists only because it was an endpoint of some edge
+                // it should have no node temporal props/metadata/type since fixture didn't add any
+                assert!(
+                    node.metadata().as_map().is_empty(),
+                    "unexpected metadata on endpoint-only node {node_id}"
+                );
+                assert!(
+                    node.properties()
+                        .temporal()
+                        .iter()
+                        .filter(|(_, v)| !v.is_empty())
+                        .next()
+                        .is_none(),
+                    "unexpected temporal props on endpoint-only node {node_id}"
+                );
+                assert_eq!(
+                    node.node_type().as_str(),
+                    None,
+                    "unexpected node_type on endpoint-only node {node_id}"
+                );
+            }
+        }
+    }
+
+    // edge-level checks
+    for edge in graph.edges().iter() {
+        let src = edge.src().id().as_u64().unwrap();
+        let dst = edge.dst().id().as_u64().unwrap();
+
+        assert!(
+            expected_edge_pairs.contains(&(src, dst)),
+            "unexpected edge pair present in graph: {src}->{dst}"
+        );
+
+        for e_layered in edge.explode_layers() {
+            let layer_name = e_layered.layer_name().unwrap_or(ArcStr::from("_default"));
+            let key = (src, dst, layer_name.clone());
+            let updates = expected_edge_layer_updates.get(&key).unwrap_or_else(|| {
+                panic!(
+                    "unexpected edge-layer present in graph: {src}->{dst} layer {:?}",
+                    layer_name
+                )
+            });
+
+            let expected_metadata = get_fixture_metadata_map(&updates.props.c_props);
+            assert_eq!(
+                e_layered.metadata().as_map(),
+                expected_metadata,
+                "mismatched edge metadata for {src}->{dst} in layer {:?}",
+                layer_name
+            );
+
+            let actual_temporal = get_edge_t_prop_counts(&e_layered);
+            let expected_temporal = get_fixture_t_prop_counts(&updates.props.t_props);
+            assert_eq!(
+                actual_temporal, expected_temporal,
+                "mismatched edge temporal properties for {src}->{dst} in layer {:?}",
+                layer_name
+            );
+
+            let mut expected_deletion_ts = updates.deletions.iter().copied().collect_vec();
+            expected_deletion_ts.sort();
+            let mut actual_del_ts = e_layered.deletions_hist().map(|(t, _)| t.t()).collect_vec();
+            actual_del_ts.sort();
+            assert_eq!(
+                actual_del_ts, expected_deletion_ts,
+                "mismatched edge deletion timestamps for {src}->{dst} in layer {:?}",
+                layer_name
+            );
+        }
+    }
+
+    // also iterate over fixture to make sure nothing is missing
+    for ((src, dst, layer), _) in fixture.edges() {
+        let layer_name = layer.unwrap_or("_default");
+        let lv = graph
+            .layers(layer_name)
+            .unwrap_or_else(|_| panic!("graph should have layer {layer_name:?}"));
+        lv.edge(src, dst).unwrap_or_else(|| {
+            panic!("graph should have edge {src}->{dst} in layer {layer_name:?}")
+        });
+    }
+
+    assert_eq!(
+        expected_edge_pairs.len(),
+        graph.count_edges(),
+        "mismatched number of unique edges (src,dst) pairs"
+    );
+
+    assert_eq!(
+        expected_exploded_edge_count,
+        graph.count_temporal_edges(),
+        "mismatched number of temporal (exploded) edge events"
+    );
+}
+
 #[macro_export]
 macro_rules! test_storage {
     ($graph:expr, $test:expr) => {
         $crate::test_utils::test_graph($graph, $test);
-        #[cfg(feature = "storage")]
-        $crate::test_utils::test_disk_graph($graph, $test);
     };
 }
 
@@ -64,6 +444,39 @@ pub fn build_edge_list_str(
     )
 }
 
+pub fn build_edge_list_with_secondary_index(
+    len: usize,
+    num_nodes: u64,
+) -> impl Strategy<Value = Vec<(u64, u64, i64, u64, String, i64)>> {
+    Just(()).prop_flat_map(move |_| {
+        // Generate a shuffled set of unique secondary indices
+        let mut secondary_index: Vec<u64> = (0..len as u64).collect();
+        let mut rng = rand::rng();
+        secondary_index.shuffle(&mut rng);
+
+        prop::collection::vec(
+            (
+                0..num_nodes,       // src
+                0..num_nodes,       // dst
+                i64::MIN..i64::MAX, // time
+                any::<String>(),    // str_prop
+                i64::MIN..i64::MAX, // int_prop
+            ),
+            len,
+        )
+        .prop_map(move |edges| {
+            // add secondary indices to the edges
+            edges
+                .into_iter()
+                .zip(secondary_index.iter())
+                .map(|((src, dst, time, str_prop, int_prop), &sec_index)| {
+                    (src, dst, time, sec_index, str_prop, int_prop)
+                })
+                .collect::<Vec<_>>()
+        })
+    })
+}
+
 pub fn build_edge_deletions(
     len: usize,
     num_nodes: u64,
@@ -129,7 +542,7 @@ pub fn prop(p_type: &PropType) -> BoxedStrategy<Prop> {
                 .map(|(k, v)| (k.clone(), v.clone()))
                 .collect();
             let len = key_val.len();
-            let samples = proptest::sample::subsequence(key_val, 0..=len);
+            let samples = proptest::sample::subsequence(key_val, 0..=len); // FIXME size 0..=len breaks type merging because empty maps {} needs looking into
             samples
                 .prop_flat_map(|key_vals| {
                     let props: Vec<_> = key_vals
@@ -153,7 +566,7 @@ pub fn prop(p_type: &PropType) -> BoxedStrategy<Prop> {
     }
 }
 
-pub fn prop_type() -> impl Strategy<Value = PropType> {
+pub fn prop_type(nested_prop_size: usize) -> impl Strategy<Value = PropType> {
     let leaf = proptest::sample::select(&[
         PropType::Str,
         PropType::I64,
@@ -162,11 +575,11 @@ pub fn prop_type() -> impl Strategy<Value = PropType> {
         PropType::Bool,
         PropType::DTime,
         PropType::NDTime,
-        // PropType::Decimal { scale }, decimal breaks the tests because of polars-parquet
+        PropType::Decimal { scale: 7 },
     ]);
 
-    leaf.prop_recursive(3, 10, 10, |inner| {
-        let dict = proptest::collection::hash_map(r"\w{1,10}", inner.clone(), 1..10)
+    leaf.prop_recursive(3, 10, 10, move |inner| {
+        let dict = proptest::collection::hash_map(r"\w{1,10}", inner.clone(), 0..=nested_prop_size) // FIXME size 0..=len breaks type merging because empty maps {} needs looking into
             .prop_map(PropType::map);
         let list = inner
             .clone()
@@ -175,12 +588,19 @@ pub fn prop_type() -> impl Strategy<Value = PropType> {
     })
 }
 
-#[derive(Debug, Clone)]
+#[derive(Clone, PartialEq, Serialize, Deserialize)]
 pub struct GraphFixture {
     pub nodes: NodeFixture,
     pub edges: EdgeFixture,
 }
 
+impl Debug for GraphFixture {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let json = serde_json::to_string(self).unwrap();
+        f.write_str(&json)
+    }
+}
+
 impl GraphFixture {
     pub fn edges(&self) -> impl Iterator<Item = ((u64, u64, Option<&str>), &EdgeUpdatesFixture)> {
         self.edges.iter()
@@ -191,9 +611,16 @@ impl GraphFixture {
     }
 }
 
-#[derive(Debug, Default, Clone)]
+#[derive(Default, Clone, PartialEq, Serialize, Deserialize)]
 pub struct NodeFixture(pub HashMap<u64, NodeUpdatesFixture>);
 
+impl Debug for NodeFixture {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let json = serde_json::to_string(self).unwrap();
+        f.write_str(&json)
+    }
+}
+
 impl FromIterator<(u64, NodeUpdatesFixture)> for NodeFixture {
     fn from_iter<T: IntoIterator<Item = (u64, NodeUpdatesFixture)>>(iter: T) -> Self {
         Self(iter.into_iter().collect())
@@ -206,38 +633,139 @@ impl NodeFixture {
     }
 }
 
-#[derive(Debug, Default, Clone)]
+impl IntoIterator for NodeFixture {
+    type Item = (u64, NodeUpdatesFixture);
+    type IntoIter = hash_map::IntoIter<u64, NodeUpdatesFixture>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_iter()
+    }
+}
+
+#[derive(Default, Clone, PartialEq, Serialize, Deserialize)]
 pub struct PropUpdatesFixture {
     pub t_props: Vec<(i64, Vec<(String, Prop)>)>,
     pub c_props: Vec<(String, Prop)>,
 }
 
-#[derive(Debug, Default, Clone)]
+impl Debug for PropUpdatesFixture {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let json = serde_json::to_string(self).unwrap();
+        f.write_str(&json)
+    }
+}
+
+#[derive(Default, Clone, PartialEq, Serialize, Deserialize)]
 pub struct NodeUpdatesFixture {
     pub props: PropUpdatesFixture,
-    pub node_type: Option<&'static str>,
+    pub node_type: Option<Cow<'static, str>>,
 }
 
-#[derive(Debug, Default, Clone)]
+impl Debug for NodeUpdatesFixture {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let json = serde_json::to_string(self).unwrap();
+        f.write_str(&json)
+    }
+}
+
+#[derive(Default, Clone, PartialEq, Serialize, Deserialize)]
 pub struct EdgeUpdatesFixture {
     pub props: PropUpdatesFixture,
     pub deletions: Vec<i64>,
 }
 
-#[derive(Debug, Default, Clone)]
-pub struct EdgeFixture(pub HashMap<(u64, u64, Option<&'static str>), EdgeUpdatesFixture>);
+impl Debug for EdgeUpdatesFixture {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let json = serde_json::to_string(self).unwrap();
+        f.write_str(&json)
+    }
+}
+
+#[derive(Default, Clone, PartialEq)]
+pub struct EdgeFixture(pub HashMap<(u64, u64, Option<Cow<'static, str>>), EdgeUpdatesFixture>);
+
+impl Serialize for EdgeFixture {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut seq = serializer.serialize_seq(Some(self.0.len()))?;
+        for v in self.iter() {
+            seq.serialize_element(&v)?;
+        }
+        seq.end()
+    }
+}
+
+struct Elements;
+
+impl<'de> Visitor<'de> for Elements {
+    type Value = EdgeFixture;
+
+    fn expecting(&self, formatter: &mut Formatter) -> std::fmt::Result {
+        formatter.write_str("a sequence edge updates")
+    }
+
+    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+    where
+        A: SeqAccess<'de>,
+    {
+        let mut elements = if let Some(size) = seq.size_hint() {
+            HashMap::with_capacity(size)
+        } else {
+            HashMap::new()
+        };
+        while let Some((next_key, next_value)) = seq.next_element()? {
+            elements.insert(next_key, next_value);
+        }
+        Ok(EdgeFixture(elements))
+    }
+}
+
+impl<'de> Deserialize<'de> for EdgeFixture {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_seq(Elements)
+    }
+}
+
+impl Debug for EdgeFixture {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let json = serde_json::to_string(self).unwrap();
+        f.write_str(&json)
+    }
+}
 
 impl EdgeFixture {
     pub fn iter(&self) -> impl Iterator<Item = ((u64, u64, Option<&str>), &EdgeUpdatesFixture)> {
-        self.0.iter().map(|(k, v)| (*k, v))
+        self.0
+            .iter()
+            .map(|((src, dst, layer), v)| ((*src, *dst, layer.as_str()), v))
+    }
+}
+
+impl IntoIterator for EdgeFixture {
+    type Item = ((u64, u64, Option<Cow<'static, str>>), EdgeUpdatesFixture);
+    type IntoIter = hash_map::IntoIter<(u64, u64, Option<Cow<'static, str>>), EdgeUpdatesFixture>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_iter()
     }
 }
 
-impl FromIterator<((u64, u64, Option<&'static str>), EdgeUpdatesFixture)> for EdgeFixture {
-    fn from_iter<T: IntoIterator<Item = ((u64, u64, Option<&'static str>), EdgeUpdatesFixture)>>(
+impl<S: Into<Cow<'static, str>>> FromIterator<((u64, u64, Option<S>), EdgeUpdatesFixture)>
+    for EdgeFixture
+{
+    fn from_iter<T: IntoIterator<Item = ((u64, u64, Option<S>), EdgeUpdatesFixture)>>(
         iter: T,
     ) -> Self {
-        Self(iter.into_iter().collect())
+        Self(
+            iter.into_iter()
+                .map(|((s, d, l), f)| ((s, d, l.map(|l| l.into())), f))
+                .collect(),
+        )
     }
 }
 
@@ -290,8 +818,19 @@ impl From<EdgeFixture> for GraphFixture {
     }
 }
 
-impl<V, T, I: IntoIterator<Item = (V, V, T, Vec<(String, Prop)>, Option<&'static str>)>> From<I>
-    for GraphFixture
+impl<
+        V,
+        T,
+        I: IntoIterator<
+            Item = (
+                V,
+                V,
+                T,
+                Vec<(String, Prop)>,
+                Option<impl Into<Cow<'static, str>>>,
+            ),
+        >,
+    > From<I> for GraphFixture
 where
     u64: TryFrom<V>,
     i64: TryFrom<T>,
@@ -301,7 +840,11 @@ where
             .into_iter()
             .filter_map(|(src, dst, t, props, layer)| {
                 Some((
-                    (src.try_into().ok()?, dst.try_into().ok()?, layer),
+                    (
+                        src.try_into().ok()?,
+                        dst.try_into().ok()?,
+                        layer.map(|l| l.into()),
+                    ),
                     (t.try_into().ok()?, props),
                 ))
             })
@@ -327,8 +870,12 @@ where
     }
 }
 
-pub fn make_node_type() -> impl Strategy<Value = Option<&'static str>> {
-    proptest::sample::select(vec![None, Some("one"), Some("two")])
+pub fn make_node_type() -> impl Strategy<Value = Option<Cow<'static, str>>> {
+    proptest::sample::select(vec![
+        None,
+        Some(Cow::Borrowed("one")),
+        Some(Cow::Borrowed("two")),
+    ])
 }
 
 pub fn make_node_types() -> impl Strategy<Value = Vec<&'static str>> {
@@ -349,23 +896,23 @@ fn make_props(schema: Vec<(String, PropType)>) -> impl Strategy<Value = Vec<(Str
     })
 }
 
-fn prop_schema(len: usize) -> impl Strategy<Value = Vec<(String, PropType)>> {
-    proptest::collection::hash_map(0..len, prop_type(), 0..=len)
+fn prop_schema(num_props: RangeInclusive<usize>) -> impl Strategy<Value = Vec<(String, PropType)>> {
+    proptest::collection::hash_map(num_props.clone(), prop_type(*num_props.end()), num_props)
         .prop_map(|v| v.into_iter().map(|(k, p)| (k.to_string(), p)).collect())
 }
 
 fn t_props(
     schema: Vec<(String, PropType)>,
-    len: usize,
+    num_props: RangeInclusive<usize>,
 ) -> impl Strategy<Value = Vec<(i64, Vec<(String, Prop)>)>> {
-    proptest::collection::vec((any::<i64>(), make_props(schema)), 0..=len)
+    proptest::collection::vec((any::<i64>(), make_props(schema)), num_props)
 }
 
 fn prop_updates(
     schema: Vec<(String, PropType)>,
-    len: usize,
+    num_props: RangeInclusive<usize>,
 ) -> impl Strategy<Value = PropUpdatesFixture> {
-    let t_props = t_props(schema.clone(), len);
+    let t_props = t_props(schema.clone(), num_props);
     let c_props = make_props(schema);
     (t_props, c_props).prop_map(|(t_props, c_props)| {
         if t_props.is_empty() {
@@ -381,71 +928,119 @@ fn prop_updates(
 
 fn node_updates(
     schema: Vec<(String, PropType)>,
-    len: usize,
+    num_updates: RangeInclusive<usize>,
 ) -> impl Strategy<Value = NodeUpdatesFixture> {
-    (prop_updates(schema, len), make_node_type())
+    (prop_updates(schema, num_updates), make_node_type())
         .prop_map(|(props, node_type)| NodeUpdatesFixture { props, node_type })
 }
 
 fn edge_updates(
     schema: Vec<(String, PropType)>,
-    len: usize,
+    num_updates: RangeInclusive<usize>,
     deletions: bool,
 ) -> impl Strategy<Value = EdgeUpdatesFixture> {
-    let del_len = if deletions { len } else { 0 };
+    let del_len = if deletions { *num_updates.end() } else { 0 };
     (
-        prop_updates(schema, len),
-        proptest::collection::vec(i64::MIN..i64::MAX, 0..=del_len),
+        prop_updates(schema, num_updates),
+        proptest::collection::vec(-150i64..150, 0..=del_len),
     )
         .prop_map(|(props, deletions)| EdgeUpdatesFixture { props, deletions })
 }
 
-pub fn build_nodes_dyn(num_nodes: usize, len: usize) -> impl Strategy<Value = NodeFixture> {
-    let schema = prop_schema(len);
+pub fn build_nodes_dyn(
+    num_nodes: RangeInclusive<usize>,
+    num_props: RangeInclusive<usize>,
+    num_updates: RangeInclusive<usize>,
+) -> impl Strategy<Value = NodeFixture> {
+    let schema = prop_schema(num_props);
     schema.prop_flat_map(move |schema| {
-        proptest::collection::hash_map(
-            0..num_nodes as u64,
-            node_updates(schema.clone(), len),
-            0..=len,
-        )
-        .prop_map(NodeFixture)
+        num_nodes
+            .clone()
+            .map(|node| {
+                (
+                    Just(node as u64),
+                    node_updates(schema.clone(), num_updates.clone()),
+                )
+            })
+            .collect_vec()
+            .prop_map(|updates| {
+                NodeFixture::from_iter(
+                    updates
+                        .into_iter()
+                        .filter(|(_, v)| !v.props.t_props.is_empty()),
+                )
+            })
     })
 }
 
 pub fn build_edge_list_dyn(
-    len: usize,
-    num_nodes: usize,
+    num_edges: RangeInclusive<usize>,
+    num_nodes: RangeInclusive<usize>,
+    num_properties: RangeInclusive<usize>,
+    num_updates: RangeInclusive<usize>,
     del_edges: bool,
 ) -> impl Strategy<Value = EdgeFixture> {
-    let num_nodes = num_nodes as u64;
-
-    let schema = prop_schema(len);
+    let schema = prop_schema(num_properties);
     schema.prop_flat_map(move |schema| {
         proptest::collection::hash_map(
             (
-                0..num_nodes,
-                0..num_nodes,
-                proptest::sample::select(vec![Some("a"), Some("b"), None]),
+                num_nodes.clone().prop_map(|n| n as u64),
+                num_nodes.clone().prop_map(|n| n as u64),
+                proptest::sample::select(vec![
+                    Some(Cow::Borrowed("a")),
+                    Some(Cow::Borrowed("b")),
+                    None,
+                ]),
             ),
-            edge_updates(schema.clone(), len, del_edges),
-            0..=len,
+            edge_updates(schema.clone(), num_updates.clone(), del_edges),
+            num_edges.clone(),
         )
-        .prop_map(EdgeFixture)
+        .prop_map(|values| {
+            EdgeFixture::from_iter(
+                values
+                    .into_iter()
+                    .filter(|(_, updates)| !updates.props.t_props.is_empty()),
+            )
+        })
     })
 }
 
-pub fn build_props_dyn(len: usize) -> impl Strategy<Value = PropUpdatesFixture> {
-    let schema = prop_schema(len);
-    schema.prop_flat_map(move |schema| prop_updates(schema, len))
+pub fn build_props_dyn(
+    num_props: RangeInclusive<usize>,
+) -> impl Strategy<Value = PropUpdatesFixture> {
+    let schema = prop_schema(num_props.clone());
+    schema.prop_flat_map(move |schema| prop_updates(schema, num_props.clone()))
 }
 
 pub fn build_graph_strat(
-    len: usize,
     num_nodes: usize,
+    num_edges: usize,
+    num_properties: usize,
+    num_updates: usize,
     del_edges: bool,
 ) -> impl Strategy<Value = GraphFixture> {
-    let nodes = build_nodes_dyn(num_nodes, len);
-    let edges = build_edge_list_dyn(len, num_nodes, del_edges);
+    build_graph_strat_r(
+        0..=num_nodes,
+        0..=num_edges,
+        0..=num_properties,
+        0..=num_updates,
+        del_edges,
+    )
+}
+
+pub fn build_graph_strat_r(
+    num_nodes: RangeInclusive<usize>,
+    num_edges: RangeInclusive<usize>,
+    num_properties: RangeInclusive<usize>,
+    num_updates: RangeInclusive<usize>,
+    del_edges: bool,
+) -> impl Strategy<Value = GraphFixture> {
+    let nodes = build_nodes_dyn(
+        num_nodes.clone(),
+        num_properties.clone(),
+        num_updates.clone(),
+    );
+    let edges = build_edge_list_dyn(num_edges, num_nodes, num_properties, num_updates, del_edges);
     (nodes, edges).prop_map(|(nodes, edges)| GraphFixture { nodes, edges })
 }
 
@@ -469,7 +1064,7 @@ pub fn build_graph_from_edge_list<'a>(
             src,
             dst,
             [
-                ("str_prop", str_prop.into_prop()),
+                ("str_prop", str_prop.as_str().into_prop()),
                 ("int_prop", int_prop.into_prop()),
             ],
             None,
@@ -489,7 +1084,7 @@ pub(crate) fn build_graph_from_edge_list_with_event_id<'a>(
             src,
             dst,
             [
-                ("str_prop", str_prop.into_prop()),
+                ("str_prop", Prop::str(str_prop.as_ref())),
                 ("int_prop", int_prop.into_prop()),
             ],
             None,
@@ -518,11 +1113,11 @@ pub fn build_graph(graph_fix: &GraphFixture) -> Arc<Storage> {
 
     for (node, updates) in graph_fix.nodes() {
         for (t, props) in updates.props.t_props.iter() {
-            g.add_node(*t, node, props.clone(), None).unwrap();
+            g.add_node(*t, node, props.clone(), None, None).unwrap();
         }
         if let Some(node) = g.node(node) {
             node.add_metadata(updates.props.c_props.clone()).unwrap();
-            if let Some(node_type) = updates.node_type {
+            if let Some(node_type) = updates.node_type.as_str() {
                 node.set_node_type(node_type).unwrap();
             }
         }
@@ -548,15 +1143,21 @@ pub fn build_graph_layer(graph_fix: &GraphFixture, layers: &[&str]) -> Arc<Stora
     }
 
     let layers = g.edge_meta().layer_meta();
+
+    let session = g.write_session().unwrap();
     for ((src, dst, layer), updates) in graph_fix.edges() {
         // properties always exist in the graph
         for (_, props) in updates.props.t_props.iter() {
             for (key, value) in props {
-                g.resolve_edge_property(key, value.dtype(), false).unwrap();
+                session
+                    .resolve_edge_property(key, value.dtype(), false)
+                    .unwrap();
             }
         }
         for (key, value) in updates.props.c_props.iter() {
-            g.resolve_edge_property(key, value.dtype(), true).unwrap();
+            session
+                .resolve_edge_property(key, value.dtype(), true)
+                .unwrap();
         }
 
         if layers.contains(layer.unwrap_or("_default")) {
@@ -582,13 +1183,13 @@ pub fn build_graph_layer(graph_fix: &GraphFixture, layers: &[&str]) -> Arc<Stora
 
     for (node, updates) in graph_fix.nodes() {
         for (t, props) in updates.props.t_props.iter() {
-            g.add_node((*t, counter), node, props.clone(), None)
+            g.add_node((*t, counter), node, props.clone(), None, None)
                 .unwrap();
             counter += 1;
         }
         if let Some(node) = g.node(node) {
             node.add_metadata(updates.props.c_props.clone()).unwrap();
-            if let Some(node_type) = updates.node_type {
+            if let Some(node_type) = updates.node_type.as_str() {
                 node.set_node_type(node_type).unwrap();
             }
         }
@@ -602,12 +1203,12 @@ pub fn add_node_props<'a>(
 ) {
     for (node, str_prop, int_prop) in nodes {
         let props = [
-            str_prop.as_ref().map(|v| ("str_prop", v.into_prop())),
+            str_prop.as_deref().map(|v| ("str_prop", v.into_prop())),
             int_prop.as_ref().map(|v| ("int_prop", (*v).into())),
         ]
         .into_iter()
         .flatten();
-        graph.add_node(0, *node, props, None).unwrap();
+        graph.add_node(0, *node, props, None, None).unwrap();
     }
 }
 
@@ -617,12 +1218,14 @@ pub(crate) fn add_node_props_with_event_id<'a>(
 ) {
     for (node, event_id, str_prop, int_prop) in nodes {
         let props = [
-            str_prop.as_ref().map(|v| ("str_prop", v.into_prop())),
+            str_prop.map(|v| ("str_prop", Prop::str(v.as_ref()))),
             int_prop.as_ref().map(|v| ("int_prop", (*v).into())),
         ]
         .into_iter()
         .flatten();
-        graph.add_node((0, event_id), node, props, None).unwrap();
+        graph
+            .add_node((0, event_id), node, props, None, None)
+            .unwrap();
     }
 }
 
@@ -658,3 +1261,229 @@ pub fn node_filtered_graph(
     );
     g
 }
+
+#[derive(Clone, Serialize, Deserialize)]
+pub enum GraphMutation {
+    AddNode {
+        node: u64,
+        time: i64,
+        props: Vec<(String, Prop)>,
+        node_type: Option<Cow<'static, str>>,
+        metadata: Vec<(String, Prop)>,
+    },
+    AddEdge {
+        src: u64,
+        dst: u64,
+        time: i64,
+        layer: Option<Cow<'static, str>>,
+        props: Vec<(String, Prop)>,
+        metadata: Vec<(String, Prop)>,
+    },
+    DeleteEdge {
+        src: u64,
+        dst: u64,
+        time: i64,
+        layer: Option<Cow<'static, str>>,
+    },
+    DropAndLoad,
+}
+
+#[derive(Clone, Serialize, Deserialize)]
+pub struct GraphMutations(pub Vec<GraphMutation>);
+
+impl Deref for GraphMutations {
+    type Target = Vec<GraphMutation>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl IntoIterator for GraphMutations {
+    type Item = GraphMutation;
+    type IntoIter = std::vec::IntoIter<Self::Item>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_iter()
+    }
+}
+
+impl Debug for GraphMutations {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let json = serde_json::to_string(self).unwrap();
+        f.write_str(&json)
+    }
+}
+
+impl Debug for GraphMutation {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let json = serde_json::to_string(self).unwrap();
+        f.write_str(&json)
+    }
+}
+
+#[derive(Clone, Serialize, Deserialize)]
+pub struct TestInput {
+    pub fixture: GraphFixture,
+    pub updates: GraphMutations,
+}
+
+impl Debug for TestInput {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let json = serde_json::to_string(self).unwrap();
+        f.write_str(&json)
+    }
+}
+
+pub fn generate_mutations(
+    num_nodes: RangeInclusive<usize>,
+    num_edges: RangeInclusive<usize>,
+    num_properties: RangeInclusive<usize>,
+    num_updates: RangeInclusive<usize>,
+    num_drops: usize,
+) -> impl Strategy<Value = TestInput> {
+    let fixture = build_graph_strat_r(num_nodes, num_edges, num_properties, num_updates, true);
+    let drops = 0..=num_drops;
+
+    (fixture, drops).prop_perturb(|(fixture, num_drops), mut rng| {
+        let mut updates = Vec::new();
+        let mut earliest = i64::MAX;
+        let mut latest = i64::MIN;
+
+        for (node, update_fixture) in fixture.nodes.clone() {
+            let mut c_props = update_fixture.props.c_props;
+            let node_type = update_fixture.node_type;
+
+            for (time, props) in update_fixture.props.t_props {
+                let metadata = mem::take(&mut c_props);
+                earliest = earliest.min(time);
+                latest = latest.max(time);
+
+                updates.push(GraphMutation::AddNode {
+                    node,
+                    time,
+                    props,
+                    node_type: node_type.clone(),
+                    metadata,
+                })
+            }
+        }
+
+        for ((src, dst, layer), update_fixture) in fixture.edges.clone() {
+            let mut c_props = update_fixture.props.c_props;
+
+            for (time, props) in update_fixture.props.t_props {
+                let metadata = mem::take(&mut c_props);
+                earliest = earliest.min(time);
+                latest = latest.max(time);
+                updates.push(GraphMutation::AddEdge {
+                    src,
+                    dst,
+                    time,
+                    layer: layer.clone(),
+                    props,
+                    metadata,
+                })
+            }
+
+            for time in update_fixture.deletions {
+                earliest = earliest.min(time);
+                latest = latest.max(time);
+                updates.push(GraphMutation::DeleteEdge {
+                    time,
+                    src,
+                    dst,
+                    layer: layer.clone(),
+                })
+            }
+        }
+
+        for _ in 0..num_drops {
+            updates.push(GraphMutation::DropAndLoad);
+        }
+
+        updates.shuffle(&mut rng);
+        TestInput {
+            fixture,
+            updates: GraphMutations(updates),
+        }
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::test_utils::{
+        EdgeFixture, EdgeUpdatesFixture, GraphFixture, NodeFixture, PropUpdatesFixture,
+    };
+    use raphtory_api::core::entities::properties::prop::Prop;
+
+    #[test]
+    fn test_debug_impl() {
+        let edges1_props = EdgeUpdatesFixture {
+            props: PropUpdatesFixture {
+                t_props: vec![
+                    (2433054617899119663, vec![]),
+                    (
+                        5623371002478468619,
+                        vec![("0".to_owned(), Prop::I64(-180204069376666762))],
+                    ),
+                ],
+                c_props: vec![],
+            },
+            deletions: vec![-3684372592923241629, 3668280323305195349],
+        };
+
+        let edges2_props = EdgeUpdatesFixture {
+            props: PropUpdatesFixture {
+                t_props: vec![
+                    (
+                        -7888823724540213280,
+                        vec![("0".to_owned(), Prop::I64(1339447446033500001))],
+                    ),
+                    (-3792330935693192039, vec![]),
+                    (
+                        4049942931077033460,
+                        vec![("0".to_owned(), Prop::I64(-544773539725842277))],
+                    ),
+                    (5085404190610173488, vec![]),
+                    (1445770503123270290, vec![]),
+                    (-5628624083683143619, vec![]),
+                    (-394401628579820652, vec![]),
+                    (-2398199704888544233, vec![]),
+                ],
+                c_props: vec![("0".to_owned(), Prop::I64(-1877019573933389749))],
+            },
+            deletions: vec![
+                3969804007878301015,
+                7040207277685112004,
+                7380699292468575143,
+                3332576590029503186,
+                -1107894292705275349,
+                6647229517972286485,
+                6359226207899406831,
+            ],
+        };
+
+        let edges: EdgeFixture = [
+            ((2, 7, Some("b")), edges1_props),
+            ((7, 2, Some("a")), edges2_props),
+        ]
+        .into_iter()
+        .collect();
+
+        let res = format!("{edges:?}");
+        let parsed: EdgeFixture = serde_json::from_str(&res).unwrap();
+
+        assert_eq!(edges, parsed);
+
+        let graph_f = GraphFixture {
+            nodes: NodeFixture::default(),
+            edges,
+        };
+
+        let res = format!("{graph_f:?}");
+        let parsed: GraphFixture = serde_json::from_str(&res).unwrap();
+
+        assert_eq!(graph_f, parsed);
+    }
+}
diff --git a/raphtory/src/vectors/mod.rs b/raphtory/src/vectors/mod.rs
index ba24193614..de2e13a4dc 100644
--- a/raphtory/src/vectors/mod.rs
+++ b/raphtory/src/vectors/mod.rs
@@ -272,6 +272,7 @@ mod vector_tests {
             "Frodo",
             [("age".to_string(), Prop::str("30"))],
             Some("hobbit"),
+            None,
         )
         .unwrap();
 
@@ -308,6 +309,7 @@ mod vector_tests {
                 ("age".to_string(), Prop::str("120")),
             ],
             None,
+            None,
         )
         .unwrap();
         g.add_node(
@@ -318,6 +320,7 @@ mod vector_tests {
                 ("age".to_string(), Prop::str("30")),
             ],
             None,
+            None,
         )
         .unwrap();
         g.add_edge(0, "Frodo", "Gandalf", NO_PROPS, Some("talk to"))
@@ -330,6 +333,7 @@ mod vector_tests {
                 ("age".to_string(), Prop::str("40")),
             ],
             None,
+            None,
         )
         .unwrap();
 
diff --git a/raphtory/src/vectors/template.rs b/raphtory/src/vectors/template.rs
index b317d70c7d..77b84d96f7 100644
--- a/raphtory/src/vectors/template.rs
+++ b/raphtory/src/vectors/template.rs
@@ -256,10 +256,10 @@ mod template_tests {
         graph.add_metadata([("name", "test-name")]).unwrap();
 
         let node1 = graph
-            .add_node(0, "node1", [("temp_test", "value_at_0")], None)
+            .add_node(0, "node1", [("temp_test", "value_at_0")], None, None)
             .unwrap();
         graph
-            .add_node(1, "node1", [("temp_test", "value_at_1")], None)
+            .add_node(1, "node1", [("temp_test", "value_at_1")], None, None)
             .unwrap();
         node1
             .add_metadata([("key1", "value1"), ("key2", "value2")])
@@ -303,16 +303,16 @@ mod template_tests {
         let graph = Graph::new();
 
         let node1 = graph
-            .add_node(0, "node1", [("temp_test", "value_at_0")], None)
+            .add_node(0, "node1", [("temp_test", "value_at_0")], None, None)
             .unwrap();
         graph
-            .add_node(1, "node1", [("temp_test", "value_at_1")], None)
+            .add_node(1, "node1", [("temp_test", "value_at_1")], None, None)
             .unwrap();
         node1
             .add_metadata([("key1", "value1"), ("key2", "value2")])
             .unwrap();
         let node2 = graph
-            .add_node(0, "node2", NO_PROPS, Some("person"))
+            .add_node(0, "node2", NO_PROPS, Some("person"), None)
             .unwrap();
         node2
             .add_metadata([("const_test", "const_test_value")])
@@ -364,7 +364,13 @@ mod template_tests {
     fn test_datetimes() {
         let graph = Graph::new();
         graph
-            .add_node("2024-09-09T09:08:01", "node1", [("temp", "value")], None)
+            .add_node(
+                "2024-09-09T09:08:01",
+                "node1",
+                [("temp", "value")],
+                None,
+                None,
+            )
             .unwrap();
 
         // I should be able to iteate over properties without doing properties|items, which would be solved by implementing Object for Properties
diff --git a/raphtory/src/vectors/vector_collection/lancedb.rs b/raphtory/src/vectors/vector_collection/lancedb.rs
index 0d9739de8f..2e86b96451 100644
--- a/raphtory/src/vectors/vector_collection/lancedb.rs
+++ b/raphtory/src/vectors/vector_collection/lancedb.rs
@@ -1,10 +1,15 @@
-use std::{ops::Deref, path::Path, sync::Arc};
-
+use crate::{
+    errors::{GraphError, GraphResult},
+    vectors::{
+        vector_collection::{CollectionPath, VectorCollection, VectorCollectionFactory},
+        Embedding,
+    },
+};
 use arrow_array::{
     builder::{FixedSizeListBuilder, Float32Builder},
     types::{Float32Type, UInt64Type},
     Array, ArrayRef, ArrowPrimitiveType, FixedSizeListArray, PrimitiveArray, RecordBatch,
-    RecordBatchIterator, UInt64Array,
+    UInt64Array,
 };
 use futures_util::TryStreamExt;
 use itertools::Itertools;
@@ -18,14 +23,7 @@ use lancedb::{
     table::{OptimizeAction, OptimizeOptions},
     Connection, DistanceType, Table,
 };
-
-use crate::{
-    errors::{GraphError, GraphResult},
-    vectors::{
-        vector_collection::{CollectionPath, VectorCollection, VectorCollectionFactory},
-        Embedding,
-    },
-};
+use std::{ops::Deref, path::Path, sync::Arc};
 
 const VECTOR_COL_NAME: &str = "vector";
 
@@ -90,14 +88,13 @@ impl VectorCollection for LanceDbCollection {
             builder.values().append_slice(&vector);
             builder.append(true);
         }
-        let batches = RecordBatchIterator::new(
-            vec![RecordBatch::try_new(
+        self.table
+            .add(RecordBatch::try_new(
                 self.schema(),
                 vec![Arc::new(UInt64Array::from(ids)), Arc::new(builder.finish())],
-            )],
-            self.schema(),
-        );
-        self.table.add(batches).execute().await?;
+            )?)
+            .execute()
+            .await?;
         Ok(())
     }
 
@@ -136,7 +133,6 @@ impl VectorCollection for LanceDbCollection {
         } else {
             limited
         };
-        let text = filtered.explain_plan(true).await?;
         let stream = filtered.execute().await?;
         let result = stream.try_collect::<Vec<_>>().await?;
 
@@ -244,8 +240,6 @@ fn get_schema(dim: usize) -> Arc<Schema> {
 
 #[cfg(test)]
 mod lancedb_tests {
-    use std::sync::Arc;
-
     use crate::vectors::{
         vector_collection::{
             lancedb::{LanceDb, LanceDbCollection},
@@ -253,6 +247,8 @@ mod lancedb_tests {
         },
         Embedding,
     };
+    use rand::Rng;
+    use std::sync::Arc;
 
     #[tokio::test]
     async fn test_search_with_candidates() {
@@ -348,7 +344,7 @@ mod lancedb_tests {
     fn embedding(id: usize) -> Embedding {
         use rand::{rngs::StdRng, Rng, SeedableRng};
         let mut rng = StdRng::seed_from_u64(id as u64);
-        let vector: Vec<f32> = (0..EMBEDDING_DIM).map(|_| rng.gen::<f32>()).collect();
+        let vector: Vec<f32> = (0..EMBEDDING_DIM).map(|_| rng.random::<f32>()).collect();
         vector.into()
     }
 
diff --git a/raphtory/tests/algo_tests/centrality.rs b/raphtory/tests/algo_tests/centrality.rs
index 8acebff9a2..85bdeedf75 100644
--- a/raphtory/tests/algo_tests/centrality.rs
+++ b/raphtory/tests/algo_tests/centrality.rs
@@ -102,22 +102,38 @@ fn test_hits() {
         graph.add_edge(0, src, dst, NO_PROPS, None).unwrap();
     }
     test_storage!(&graph, |graph| {
-        let results = hits(graph, 20, None).to_hashmap(|value| (value.hub_score, value.auth_score));
-
-        assert_eq!(
-            results,
-            HashMap::from([
-                ("1".to_string(), (0.0431365, 0.096625775)),
-                ("2".to_string(), (0.14359662, 0.18366566)),
-                ("3".to_string(), (0.030866561, 0.36886504)),
-                ("4".to_string(), (0.1865414, 0.12442485)),
-                ("5".to_string(), (0.26667944, 0.05943252)),
-                ("6".to_string(), (0.14359662, 0.10755368)),
-                ("7".to_string(), (0.15471625, 0.0)),
-                ("8".to_string(), (0.030866561, 0.05943252))
-            ])
-        );
-    });
+        let results = hits(graph, 20, None);
+
+        let expected = HashMap::from([
+            ("1".to_string(), (0.0431365, 0.096625775)),
+            ("2".to_string(), (0.14359662, 0.18366566)),
+            ("3".to_string(), (0.030866561, 0.36886504)),
+            ("4".to_string(), (0.1865414, 0.12442485)),
+            ("5".to_string(), (0.26667944, 0.05943252)),
+            ("6".to_string(), (0.14359662, 0.10755368)),
+            ("7".to_string(), (0.15471625, 0.0)),
+            ("8".to_string(), (0.030866561, 0.05943252)),
+        ]);
+
+        assert_eq!(results.len(), 8);
+        for (node, value) in results.iter() {
+            let expected_value = expected.get(&node.name()).unwrap();
+            assert!(
+                (value.hub_score - expected_value.0).abs() < 1e-6,
+                "mismatched hub score for node {}, expected {}, actual {}",
+                node.name(),
+                expected_value.0,
+                value.hub_score
+            );
+            assert!(
+                (value.auth_score - expected_value.1).abs() < 1e-6,
+                "mismatched authority score for node {}, expected {}, actual {}",
+                node.name(),
+                expected_value.1,
+                value.auth_score
+            );
+        }
+    })
 }
 
 #[test]
diff --git a/raphtory/tests/algo_tests/components.rs b/raphtory/tests/algo_tests/components.rs
index 8c62b6dcd1..9f78836ce6 100644
--- a/raphtory/tests/algo_tests/components.rs
+++ b/raphtory/tests/algo_tests/components.rs
@@ -1,7 +1,9 @@
 use ahash::HashSet;
 use proptest::{prelude::Strategy, proptest, sample::Index};
 use raphtory::{
-    algorithms::components::weakly_connected_components,
+    algorithms::components::{
+        weakly_connected_components, ConnectedComponent, LargestConnectedComponent,
+    },
     db::api::{
         mutation::AdditionOps,
         state::{NodeStateValue, TypedNodeState},
@@ -10,7 +12,10 @@ use raphtory::{
     prelude::*,
     test_storage,
 };
-use std::{collections::BTreeSet, hash::Hash};
+use std::{
+    collections::{BTreeSet, HashMap},
+    hash::Hash,
+};
 
 fn assert_same_partition<
     V: NodeStateValue + Hash + Eq + 'static,
@@ -159,6 +164,38 @@ fn windowed_connected_components() {
     });
 }
 
+#[test]
+fn layered_connected_components() {
+    let g = Graph::new();
+    g.add_edge(0, 1, 2, NO_PROPS, Some("ZERO-TWO")).unwrap();
+    g.add_edge(1, 1, 3, NO_PROPS, Some("ZERO-TWO")).unwrap();
+    g.add_edge(2, 4, 5, NO_PROPS, Some("ZERO-TWO")).unwrap();
+    g.add_edge(3, 6, 7, NO_PROPS, Some("THREE-FIVE")).unwrap();
+    g.add_edge(4, 8, 9, NO_PROPS, Some("THREE-FIVE")).unwrap();
+
+    let g_layer_zero_two = g.layers("ZERO-TWO").unwrap();
+
+    assert_eq!(g_layer_zero_two.nodes().id(), [1, 2, 3, 4, 5]);
+    let g_layer_three_five = g.layers("THREE-FIVE").unwrap();
+
+    let res_zero_two = weakly_connected_components(&g_layer_zero_two);
+    let c1 = res_zero_two.get_by_node(1).unwrap();
+    let c2 = res_zero_two.get_by_node(4).unwrap();
+
+    let expected_zero_two: HashMap<u64, ConnectedComponent> =
+        [(1, c1), (2, c1), (3, c1), (4, c2), (5, c2)].into();
+
+    assert_eq!(res_zero_two, expected_zero_two);
+
+    let res_three_five = weakly_connected_components(&g_layer_three_five);
+
+    let c6 = res_three_five.get_by_node(6).unwrap().component_id;
+    let c7 = res_three_five.get_by_node(8).unwrap().component_id;
+
+    let expected_three_five: HashMap<u64, usize> = [(6u64, c6), (7, c6), (8, c7), (9, c7)].into();
+    assert_eq!(res_three_five, expected_three_five);
+}
+
 fn random_component_edges(
     num_components: usize,
     num_nodes_per_component: usize,
@@ -437,7 +474,7 @@ mod in_component_test {
                 .nodes()
                 .in_neighbours()
                 .iter()
-                .flat_map(|ns| ns.iter().filter_map(|c| c.id().as_u64()))
+                .flat_map(|(_, ns)| ns.iter().filter_map(|c| c.id().as_u64()))
                 .collect();
 
         assert_eq!(unfiltered_ids, vec![99]);
@@ -481,7 +518,7 @@ mod components_test {
             out_component, out_component_filtered, out_components, out_components_filtered,
         },
         db::{
-            api::{mutation::AdditionOps, view::history::InternalHistoryOps},
+            api::mutation::AdditionOps,
             graph::views::filter::{
                 model::{
                     graph_filter::GraphFilter, property_filter::ops::PropertyFilterOps,
@@ -493,7 +530,6 @@ mod components_test {
         prelude::*,
         test_storage,
     };
-    use raphtory_api::core::entities::VID;
     use std::collections::HashMap;
 
     fn check_node(graph: &Graph, node_id: u64, mut correct: Vec<(u64, usize)>) {
@@ -706,13 +742,13 @@ mod components_test {
         graph.add_edge(1, 2, 99, NO_PROPS, Some("B")).unwrap();
         graph.add_edge(1, 99, 100, NO_PROPS, Some("B")).unwrap();
 
-        let mut unfiltered_ids: Vec<u64> =
+        let unfiltered_ids: Vec<u64> =
             out_component_filtered(graph.node(1).unwrap(), GraphFilter.layer("A"))
                 .unwrap()
                 .nodes()
                 .out_neighbours()
                 .iter()
-                .flat_map(|ns| ns.iter().filter_map(|c| c.id().as_u64()))
+                .flat_map(|(_, ns)| ns.iter().filter_map(|c| c.id().as_u64()))
                 .collect();
 
         assert_eq!(unfiltered_ids, vec![99]);
@@ -723,16 +759,16 @@ mod components_test {
         let graph = Graph::new();
 
         graph
-            .add_node(1, 1, vec![("p1", Prop::U64(1))], None)
+            .add_node(1, 1, vec![("p1", Prop::U64(1))], None, None)
             .unwrap();
         graph
-            .add_node(1, 2, vec![("p1", Prop::U64(2))], None)
+            .add_node(1, 2, vec![("p1", Prop::U64(2))], None, None)
             .unwrap();
         graph
-            .add_node(1, 3, vec![("p1", Prop::U64(3))], None)
+            .add_node(1, 3, vec![("p1", Prop::U64(3))], None, None)
             .unwrap();
         graph
-            .add_node(1, 4, vec![("p1", Prop::U64(4))], None)
+            .add_node(1, 4, vec![("p1", Prop::U64(4))], None, None)
             .unwrap();
 
         graph.add_edge(1, 1, 2, NO_PROPS, Some("A")).unwrap();
diff --git a/raphtory/tests/algo_tests/embeddings.rs b/raphtory/tests/algo_tests/embeddings.rs
index e05606d9e2..d263804709 100644
--- a/raphtory/tests/algo_tests/embeddings.rs
+++ b/raphtory/tests/algo_tests/embeddings.rs
@@ -8,6 +8,7 @@ mod fast_rp_test {
     use std::collections::HashMap;
 
     #[test]
+    #[ignore = "this failed once we changed rand to 0.9.2, needs some tweaking, it looks like a motion detection test"]
     fn simple_fast_rp_test() {
         let graph = Graph::new();
 
diff --git a/raphtory/tests/cached_view.rs b/raphtory/tests/cached_view.rs
index e06bb26731..be46bff733 100644
--- a/raphtory/tests/cached_view.rs
+++ b/raphtory/tests/cached_view.rs
@@ -30,8 +30,8 @@ fn empty_window() {
 fn test_materialize_no_edges() {
     let graph = Graph::new();
 
-    graph.add_node(1, 1, NO_PROPS, None).unwrap();
-    graph.add_node(2, 2, NO_PROPS, None).unwrap();
+    graph.add_node(1, 1, NO_PROPS, None, None).unwrap();
+    graph.add_node(2, 2, NO_PROPS, None, None).unwrap();
 
     test_storage!(&graph, |graph| {
         let sg = graph.cache_view();
@@ -195,7 +195,7 @@ mod test_filters_cached_view {
 
             for (ts, name, value, kind) in node_data {
                 graph
-                    .add_node(ts, name, [("p1", Prop::U64(value))], Some(kind))
+                    .add_node(ts, name, [("p1", Prop::U64(value))], Some(kind), None)
                     .unwrap();
             }
 
diff --git a/raphtory/tests/db_tests.rs b/raphtory/tests/db_tests.rs
index 45ee569712..4e3219ea39 100644
--- a/raphtory/tests/db_tests.rs
+++ b/raphtory/tests/db_tests.rs
@@ -5,10 +5,14 @@ use proptest::{arbitrary::any, prop_assert, prop_assert_eq, proptest, sample::su
 #[cfg(feature = "proto")]
 use raphtory::serialise::StableDecode;
 use raphtory::{
-    algorithms::components::weakly_connected_components,
+    algorithms::{
+        centrality::{degree_centrality::degree_centrality, pagerank::unweighted_page_rank},
+        components::weakly_connected_components,
+    },
     db::{
         api::{
             properties::internal::InternalMetadataOps,
+            state::MergePriority,
             view::{
                 internal::{GraphTimeSemanticsOps, InternalEdgeFilterOps},
                 EdgeViewOps, LayerOps, NodeViewOps, TimeOps,
@@ -23,10 +27,13 @@ use raphtory::{
     graphgen::random_attachment::random_attachment,
     prelude::*,
     test_storage,
-    test_utils::{EdgeFixture, EdgeUpdatesFixture, GraphFixture, NodeFixture, PropUpdatesFixture},
+    test_utils::{
+        build_graph, build_graph_strat, EdgeFixture, EdgeUpdatesFixture, GraphFixture, NodeFixture,
+        PropUpdatesFixture,
+    },
 };
 use raphtory_api::core::{
-    entities::{GID, VID},
+    entities::{LayerId, GID, VID},
     storage::{
         arc_str::{ArcStr, OptionAsStr},
         timeindex::{AsTime, EventTime},
@@ -152,6 +159,25 @@ fn test_multithreaded_add_edge() {
     });
 }
 
+#[test]
+fn test_multithreaded_add_edge_both_directions() {
+    proptest!(|(edges: Vec<(u64, u64)>)| {
+        let g = Graph::new();
+        let mut self_loop_count = 0;
+        for (src, dst) in edges.iter() {
+            if src == dst {
+                self_loop_count += 1;
+            }
+            // try to maximise the chance that both directions of the edge are added in parallel
+            join(|| {
+                g.add_edge(0, *src, *dst, NO_PROPS, None).unwrap();
+            }, || {g.add_edge(0, *dst, *src, NO_PROPS, None).unwrap();});
+        }
+
+        prop_assert!(edges.iter().all(|(i, j)| g.has_edge(*i, *j) && g.has_edge(*j, *i)) && g.count_temporal_edges() == 2*edges.len()-self_loop_count);
+    });
+}
+
 #[test]
 fn add_node_grows_graph_len() {
     proptest!(|(vs: Vec<(i64, u64)>)| {
@@ -159,7 +185,7 @@ fn add_node_grows_graph_len() {
 
         let expected_len = vs.iter().map(|(_, v)| v).sorted().dedup().count();
         for (t, v) in vs {
-            g.add_node(t, v, NO_PROPS, None)
+            g.add_node(t, v, NO_PROPS, None, None)
                 .map_err(|err| error!("{:?}", err))
                 .ok();
         }
@@ -176,7 +202,7 @@ fn add_node_gets_names() {
 
         let expected_len = vs.iter().sorted().dedup().count();
         for (t, name) in vs.iter().enumerate() {
-            g.add_node(t as i64, name.clone(), NO_PROPS, None)
+            g.add_node(t as i64, name.clone(), NO_PROPS, None, None)
                 .map_err(|err| info!("{:?}", err))
                 .ok();
         }
@@ -219,7 +245,7 @@ fn add_edge_grows_graph_edge_len() {
 }
 
 #[test]
-fn simle_add_edge() {
+fn simple_add_edge() {
     let edges = vec![(1, 1, 2), (2, 2, 3), (3, 3, 4)];
 
     let g = Graph::new();
@@ -259,9 +285,15 @@ fn get_edge_works() {
 #[test]
 fn import_from_another_graph() {
     let g = Graph::new();
-    let g_a = g.add_node(0, "A", NO_PROPS, None).unwrap();
+    let g_a = g.add_node(0, "A", NO_PROPS, None, None).unwrap();
     let g_b = g
-        .add_node(1, "B", vec![("temp".to_string(), Prop::Bool(true))], None)
+        .add_node(
+            1,
+            "B",
+            vec![("temp".to_string(), Prop::Bool(true))],
+            None,
+            None,
+        )
         .unwrap();
 
     assert_eq!(g_b.history(), vec![1]);
@@ -277,7 +309,7 @@ fn import_from_another_graph() {
     assert_eq!(res.metadata().get("con").unwrap(), Prop::I64(11));
 
     let gg = Graph::new();
-    gg.add_node(1, "B", NO_PROPS, None).unwrap();
+    gg.add_node(1, "B", NO_PROPS, None, None).unwrap();
     let res = gg.import_nodes(vec![&g_a, &g_b], false);
     match res {
         Err(GraphError::NodesExistError(ids)) => {
@@ -314,7 +346,7 @@ fn import_from_another_graph() {
         )
         .unwrap();
     let gg = Graph::new();
-    let _ = gg.add_node(0, "B", NO_PROPS, None);
+    let _ = gg.add_node(0, "B", NO_PROPS, None, None);
     let res = gg.import_edge(&e_a_b_p, false).expect("Failed to add edge");
     assert_eq!(res.properties().as_vec(), e_a_b_p.properties().as_vec());
 
@@ -346,9 +378,15 @@ fn import_from_another_graph() {
 #[test]
 fn import_node_as() {
     let g = Graph::new();
-    let g_a = g.add_node(0, "A", NO_PROPS, None).unwrap();
+    let g_a = g.add_node(0, "A", NO_PROPS, None, None).unwrap();
     let g_b = g
-        .add_node(1, "B", vec![("temp".to_string(), Prop::Bool(true))], None)
+        .add_node(
+            1,
+            "B",
+            vec![("temp".to_string(), Prop::Bool(true))],
+            None,
+            None,
+        )
         .unwrap();
     let _ = g_b.add_metadata(vec![("con".to_string(), Prop::I64(11))]);
 
@@ -357,7 +395,7 @@ fn import_node_as() {
     assert_eq!(res.name(), "X");
     assert_eq!(res.history(), vec![0]);
 
-    let _ = gg.add_node(1, "Y", NO_PROPS, None).unwrap();
+    let _ = gg.add_node(1, "Y", NO_PROPS, None, None).unwrap();
     let res = gg.import_node_as(&g_b, "Y", false);
     match res {
         Err(GraphError::NodeExistsError(id)) => {
@@ -381,14 +419,20 @@ fn import_node_as() {
 #[test]
 fn import_node_as_merge() {
     let g = Graph::new();
-    let g_a = g.add_node(0, "A", NO_PROPS, None).unwrap();
+    let g_a = g.add_node(0, "A", NO_PROPS, None, None).unwrap();
     let g_b = g
-        .add_node(1, "B", vec![("temp".to_string(), Prop::Bool(true))], None)
+        .add_node(
+            1,
+            "B",
+            vec![("temp".to_string(), Prop::Bool(true))],
+            None,
+            None,
+        )
         .unwrap();
     let _ = g_b.add_metadata(vec![("con".to_string(), Prop::I64(11))]);
 
     let gg = Graph::new();
-    gg.add_node(1, "Y", NO_PROPS, None).unwrap();
+    gg.add_node(1, "Y", NO_PROPS, None, None).unwrap();
 
     let res = gg.import_node_as(&g_a, "X", false).unwrap();
     assert_eq!(res.name(), "X");
@@ -404,16 +448,22 @@ fn import_node_as_merge() {
 #[test]
 fn import_nodes_as() {
     let g = Graph::new();
-    let g_a = g.add_node(0, "A", NO_PROPS, None).unwrap();
+    let g_a = g.add_node(0, "A", NO_PROPS, None, None).unwrap();
     let g_b = g
-        .add_node(1, "B", vec![("temp".to_string(), Prop::Bool(true))], None)
+        .add_node(
+            1,
+            "B",
+            vec![("temp".to_string(), Prop::Bool(true))],
+            None,
+            None,
+        )
         .unwrap();
     let _ = g_b.add_metadata(vec![("con".to_string(), Prop::I64(11))]);
-    let g_c = g.add_node(0, "C", NO_PROPS, None).unwrap();
+    let g_c = g.add_node(0, "C", NO_PROPS, None, None).unwrap();
 
     let gg = Graph::new();
-    gg.add_node(1, "Q", NO_PROPS, None).unwrap();
-    gg.add_node(1, "R", NO_PROPS, None).unwrap();
+    gg.add_node(1, "Q", NO_PROPS, None, None).unwrap();
+    gg.add_node(1, "R", NO_PROPS, None, None).unwrap();
     let res = gg.import_nodes_as(vec![&g_a, &g_b, &g_c], vec!["P", "Q", "R"], false);
     match res {
         Err(GraphError::NodesExistError(ids)) => {
@@ -440,14 +490,20 @@ fn import_nodes_as() {
 #[test]
 fn import_nodes_as_merge() {
     let g = Graph::new();
-    let g_a = g.add_node(0, "A", NO_PROPS, None).unwrap();
+    let g_a = g.add_node(0, "A", NO_PROPS, None, None).unwrap();
     let g_b = g
-        .add_node(1, "B", vec![("temp".to_string(), Prop::Bool(true))], None)
+        .add_node(
+            1,
+            "B",
+            vec![("temp".to_string(), Prop::Bool(true))],
+            None,
+            None,
+        )
         .unwrap();
     let _ = g_b.add_metadata(vec![("con".to_string(), Prop::I64(11))]);
 
     let gg = Graph::new();
-    gg.add_node(1, "Q", NO_PROPS, None).unwrap();
+    gg.add_node(1, "Q", NO_PROPS, None, None).unwrap();
     gg.import_nodes_as(vec![&g_a, &g_b], vec!["P", "Q"], true)
         .unwrap();
     let mut nodes = gg.nodes().name().collect_vec();
@@ -463,9 +519,15 @@ fn import_nodes_as_merge() {
 #[test]
 fn import_edge_as() {
     let g = Graph::new();
-    g.add_node(0, "A", NO_PROPS, None).unwrap();
+    g.add_node(0, "A", NO_PROPS, None, None).unwrap();
     let g_b = g
-        .add_node(1, "B", vec![("temp".to_string(), Prop::Bool(true))], None)
+        .add_node(
+            1,
+            "B",
+            vec![("temp".to_string(), Prop::Bool(true))],
+            None,
+            None,
+        )
         .unwrap();
     g_b.add_metadata(vec![("con".to_string(), Prop::I64(11))])
         .unwrap();
@@ -524,9 +586,15 @@ fn import_edge_as() {
 #[test]
 fn import_edge_as_merge() {
     let g = Graph::new();
-    g.add_node(0, "A", NO_PROPS, None).unwrap();
+    g.add_node(0, "A", NO_PROPS, None, None).unwrap();
     let g_b = g
-        .add_node(1, "B", vec![("temp".to_string(), Prop::Bool(true))], None)
+        .add_node(
+            1,
+            "B",
+            vec![("temp".to_string(), Prop::Bool(true))],
+            None,
+            None,
+        )
         .unwrap();
     let _ = g_b.add_metadata(vec![("con".to_string(), Prop::I64(11))]);
     let e_a_b = g
@@ -561,13 +629,19 @@ fn import_edge_as_merge() {
 #[test]
 fn import_edges_as() {
     let g = Graph::new();
-    g.add_node(0, "A", NO_PROPS, None).unwrap();
+    g.add_node(0, "A", NO_PROPS, None, None).unwrap();
     let g_b = g
-        .add_node(1, "B", vec![("temp".to_string(), Prop::Bool(true))], None)
+        .add_node(
+            1,
+            "B",
+            vec![("temp".to_string(), Prop::Bool(true))],
+            None,
+            None,
+        )
         .unwrap();
     g_b.add_metadata(vec![("con".to_string(), Prop::I64(11))])
         .unwrap();
-    g.add_node(0, "C", NO_PROPS, None).unwrap();
+    g.add_node(0, "C", NO_PROPS, None, None).unwrap();
     let e_a_b = g
         .add_edge(
             2,
@@ -622,9 +696,15 @@ fn import_edges_as() {
 #[test]
 fn import_edges_as_merge() {
     let g = Graph::new();
-    g.add_node(0, "A", NO_PROPS, None).unwrap();
+    g.add_node(0, "A", NO_PROPS, None, None).unwrap();
     let g_b = g
-        .add_node(1, "B", vec![("temp".to_string(), Prop::Bool(true))], None)
+        .add_node(
+            1,
+            "B",
+            vec![("temp".to_string(), Prop::Bool(true))],
+            None,
+            None,
+        )
         .unwrap();
     let _ = g_b.add_metadata(vec![("con".to_string(), Prop::I64(11))]);
     let e_a_b = g
@@ -749,6 +829,7 @@ fn graph_edge() {
             .unwrap()
             .edge(1, 3)
             .unwrap();
+
         assert_eq!(e.src().id().into_u64(), Some(1u64));
         assert_eq!(e.dst().id().into_u64(), Some(3u64));
     });
@@ -895,7 +976,7 @@ fn time_test() {
     assert_eq!(g.latest_time(), None);
     assert_eq!(g.earliest_time(), None);
 
-    g.add_node(5, 1, NO_PROPS, None)
+    g.add_node(5, 1, NO_PROPS, None, None)
         .map_err(|err| error!("{:?}", err))
         .ok();
 
@@ -908,7 +989,7 @@ fn time_test() {
     assert_eq!(g.latest_time().unwrap().t(), 10);
     assert_eq!(g.earliest_time().unwrap().t(), 10);
 
-    g.add_node(5, 1, NO_PROPS, None)
+    g.add_node(5, 1, NO_PROPS, None, None)
         .map_err(|err| error!("{:?}", err))
         .ok();
     assert_eq!(g.latest_time().unwrap().t(), 10);
@@ -926,9 +1007,9 @@ fn time_test() {
 #[test]
 fn test_metadata_props() {
     let g = Graph::new();
-    let n = g.add_node(1, 1, [("p1", 1)], None).unwrap();
+    let n = g.add_node(1, 1, [("p1", 1)], None, None).unwrap();
     n.add_metadata([("m1", 1)]).unwrap();
-    let n = g.add_node(1, 2, [("p2", 2)], None).unwrap();
+    let n = g.add_node(1, 2, [("p2", 2)], None, None).unwrap();
     n.add_metadata([("m2", 2)]).unwrap();
 
     let n1_meta = g
@@ -963,8 +1044,14 @@ fn metadata() {
     .unwrap();
     g.add_edge(0, 22, 33, NO_PROPS, None).unwrap();
     g.add_edge(0, 33, 11, NO_PROPS, None).unwrap();
-    g.add_node(0, 11, vec![("temp".to_string(), Prop::Bool(true))], None)
-        .unwrap();
+    g.add_node(
+        0,
+        11,
+        vec![("temp".to_string(), Prop::Bool(true))],
+        None,
+        None,
+    )
+    .unwrap();
     g.add_edge(0, 44, 55, NO_PROPS, None).unwrap();
     let v11 = g.node(11).unwrap();
     let v22 = g.node(22).unwrap();
@@ -1047,7 +1134,7 @@ fn temporal_node_rows_1_node() {
     let graph = Graph::new();
 
     graph
-        .add_node(0, 1, [("cool".to_string(), Prop::Bool(true))], None)
+        .add_node(0, 1, [("cool".to_string(), Prop::Bool(true))], None, None)
         .unwrap();
 
     test_storage!(&graph, |graph| {
@@ -1055,14 +1142,14 @@ fn temporal_node_rows_1_node() {
             .node(1)
             .unwrap()
             .rows()
-            .map(|(t, row)| (t, row.into_iter().map(|(_, a)| a).collect::<Vec<_>>()))
+            .map(|(t, _, row)| (t, row.into_iter().map(|(_, a)| a).collect::<Vec<_>>()))
             .collect::<Vec<_>>();
 
         assert_eq!(actual, vec![(0.into(), vec![Prop::Bool(true)])]);
     });
 
     graph
-        .add_node(0, 1, [("coolio".to_string(), Prop::U64(9))], None)
+        .add_node(0, 1, [("coolio".to_string(), Prop::U64(9))], None, None)
         .unwrap();
 
     test_storage!(&graph, |graph| {
@@ -1070,7 +1157,7 @@ fn temporal_node_rows_1_node() {
             .node(1)
             .unwrap()
             .rows()
-            .map(|(t, row)| (t, row.into_iter().map(|(_, a)| a).collect::<Vec<_>>()))
+            .map(|(t, _, row)| (t, row.into_iter().map(|(_, a)| a).collect::<Vec<_>>()))
             .collect::<Vec<_>>();
 
         assert_eq!(
@@ -1091,6 +1178,7 @@ fn temporal_node_rows_1_node() {
                 ("coolio".to_string(), Prop::U64(19)),
             ],
             None,
+            None,
         )
         .unwrap();
 
@@ -1099,7 +1187,7 @@ fn temporal_node_rows_1_node() {
             .node(1)
             .unwrap()
             .rows()
-            .map(|(t, row)| (t, row.into_iter().map(|(_, a)| a).collect::<Vec<_>>()))
+            .map(|(t, _, row)| (t, row.into_iter().map(|(_, a)| a).collect::<Vec<_>>()))
             .collect::<Vec<_>>();
 
         let expected = vec![
@@ -1110,7 +1198,7 @@ fn temporal_node_rows_1_node() {
         assert_eq!(actual, expected);
     });
 
-    graph.add_node(2, 1, NO_PROPS, None).unwrap();
+    graph.add_node(2, 1, NO_PROPS, None, None).unwrap();
     // edge additions should not show up in prop rows
     graph.add_edge(3, 1, 1, NO_PROPS, None).unwrap();
 
@@ -1119,7 +1207,7 @@ fn temporal_node_rows_1_node() {
             .node(1)
             .unwrap()
             .rows()
-            .map(|(t, row)| (t, row.into_iter().map(|(_, a)| a).collect::<Vec<_>>()))
+            .map(|(t, _, row)| (t, row.into_iter().map(|(_, a)| a).collect::<Vec<_>>()))
             .collect::<Vec<_>>();
 
         let expected = vec![
@@ -1136,47 +1224,54 @@ fn temporal_node_rows_1_node() {
 #[test]
 fn temporal_node_rows_nodes() {
     let graph = Graph::new();
+    let mut nodes = Vec::new();
+    nodes.push(
+        graph
+            .add_node(0, 1, [("cool".to_string(), Prop::U64(1))], None, None)
+            .unwrap()
+            .node,
+    );
+    nodes.push(
+        graph
+            .add_node(1, 2, [("cool".to_string(), Prop::U64(2))], None, None)
+            .unwrap()
+            .node,
+    );
+    nodes.push(
+        graph
+            .add_node(2, 3, [("cool".to_string(), Prop::U64(3))], None, None)
+            .unwrap()
+            .node,
+    );
 
-    graph
-        .add_node(0, 1, [("cool".to_string(), Prop::U64(1))], None)
-        .unwrap();
-    graph
-        .add_node(1, 2, [("cool".to_string(), Prop::U64(2))], None)
-        .unwrap();
-    graph
-        .add_node(2, 3, [("cool".to_string(), Prop::U64(3))], None)
-        .unwrap();
+    for (id, n) in nodes.into_iter().enumerate() {
+        let actual = graph
+            .core_graph()
+            .nodes()
+            .node(n)
+            .temp_prop_rows()
+            .map(|(t, _, row)| (t, row.into_iter().map(|(_, p)| p).collect::<Vec<_>>()))
+            .collect::<Vec<_>>();
 
-    test_storage!(&graph, |graph| {
-        for id in 0..3 {
-            let actual = graph
-                .core_graph()
-                .nodes()
-                .node(VID(id))
-                .temp_prop_rows()
-                .map(|(t, row)| (t, row.into_iter().map(|(_, p)| p).collect::<Vec<_>>()))
-                .collect::<Vec<_>>();
-
-            let expected = vec![(
-                EventTime::new(id as i64, id),
-                vec![Some(Prop::U64((id as u64) + 1))],
-            )];
-            assert_eq!(actual, expected);
-        }
-    });
+        let expected = vec![(
+            EventTime::new(id as i64, id),
+            vec![Prop::U64((id as u64) + 1)],
+        )];
+        assert_eq!(actual, expected);
+    }
 }
 
 #[test]
 fn temporal_node_rows_window() {
     let graph = Graph::new();
     graph
-        .add_node(0, 1, [("cool".to_string(), Prop::U64(1))], None)
+        .add_node(0, 1, [("cool".to_string(), Prop::U64(1))], None, None)
         .unwrap();
     graph
-        .add_node(1, 1, [("cool".to_string(), Prop::U64(2))], None)
+        .add_node(1, 1, [("cool".to_string(), Prop::U64(2))], None, None)
         .unwrap();
     graph
-        .add_node(2, 1, [("cool".to_string(), Prop::U64(3))], None)
+        .add_node(2, 1, [("cool".to_string(), Prop::U64(3))], None, None)
         .unwrap();
 
     test_storage!(&graph, |graph| {
@@ -1185,21 +1280,21 @@ fn temporal_node_rows_window() {
                 .core_graph()
                 .nodes()
                 .node(vid)
-                .temp_prop_rows_window(range)
-                .map(|(t, row)| (t, row.into_iter().map(|(_, p)| p).collect::<Vec<_>>()))
+                .temp_prop_rows_range(Some(range))
+                .map(|(t, _, row)| (t, row.into_iter().map(|(_, p)| p).collect::<Vec<_>>()))
                 .collect::<Vec<_>>()
         };
         let actual = get_rows(VID(0), EventTime::new(2, 0)..EventTime::new(3, 0));
 
-        let expected = vec![(EventTime::new(2, 2), vec![Some(Prop::U64(3))])];
+        let expected = vec![(EventTime::new(2, 2), vec![Prop::U64(3)])];
 
         assert_eq!(actual, expected);
 
         let actual = get_rows(VID(0), EventTime::new(0, 0)..EventTime::new(3, 0));
         let expected = vec![
-            (EventTime::new(0, 0), vec![Some(Prop::U64(1))]),
-            (EventTime::new(1, 1), vec![Some(Prop::U64(2))]),
-            (EventTime::new(2, 2), vec![Some(Prop::U64(3))]),
+            (EventTime::new(0, 0), vec![Prop::U64(1)]),
+            (EventTime::new(1, 1), vec![Prop::U64(2)]),
+            (EventTime::new(2, 2), vec![Prop::U64(3)]),
         ];
 
         assert_eq!(actual, expected);
@@ -1211,7 +1306,7 @@ fn temporal_props_node() {
     let graph = Graph::new();
 
     graph
-        .add_node(0, 1, [("cool".to_string(), Prop::Bool(true))], None)
+        .add_node(0, 1, [("cool".to_string(), Prop::Bool(true))], None, None)
         .unwrap();
 
     let v = graph.node(1).unwrap();
@@ -1221,7 +1316,7 @@ fn temporal_props_node() {
 
     // we flip cool from true to false after t 3
     graph
-        .add_node(3, 1, [("cool".to_string(), Prop::Bool(false))], None)
+        .add_node(3, 1, [("cool".to_string(), Prop::Bool(false))], None, None)
         .unwrap();
 
     test_storage!(&graph, |graph| {
@@ -1337,7 +1432,7 @@ fn test_time_range_on_empty_graph() {
 fn test_add_node_with_nums() {
     let graph = Graph::new();
 
-    graph.add_node(1, 831, NO_PROPS, None).unwrap();
+    graph.add_node(1, 831, NO_PROPS, None, None).unwrap();
     test_storage!(&graph, |graph| {
         assert!(graph.has_node(831));
 
@@ -1349,8 +1444,8 @@ fn test_add_node_with_nums() {
 fn test_add_node_with_strings() {
     let graph = Graph::new();
 
-    graph.add_node(0, "haaroon", NO_PROPS, None).unwrap();
-    graph.add_node(1, "hamza", NO_PROPS, None).unwrap();
+    graph.add_node(0, "haaroon", NO_PROPS, None, None).unwrap();
+    graph.add_node(1, "hamza", NO_PROPS, None, None).unwrap();
     test_storage!(&graph, |graph| {
         assert!(graph.has_node("haaroon"));
         assert!(graph.has_node("hamza"));
@@ -1369,122 +1464,106 @@ fn layers() -> Result<(), GraphError> {
     graph.add_edge(0, 11, 33, NO_PROPS, Some("layer2"))?;
     graph.add_edge(0, 11, 44, NO_PROPS, Some("layer2"))?;
 
-    test_storage!(&graph, |graph| {
-        assert!(graph.has_edge(11, 22));
-        assert!(graph.default_layer().has_edge(11, 22));
-        assert!(!graph.default_layer().has_edge(11, 44));
-        assert!(!graph.layers("layer2").unwrap().has_edge(11, 22));
-        assert!(graph.layers("layer2").unwrap().has_edge(11, 44));
-
-        assert!(graph.edge(11, 22).is_some());
-        assert!(graph.layers(Layer::Default).unwrap().edge(11, 44).is_none());
-        assert!(graph.layers("layer2").unwrap().edge(11, 22).is_none());
-        assert!(graph.layers("layer2").unwrap().edge(11, 44).is_some());
+    assert!(graph.has_edge(11, 22));
+    assert!(graph.default_layer().has_edge(11, 22));
+    assert!(!graph.default_layer().has_edge(11, 44));
+    assert!(!graph.layers("layer2")?.has_edge(11, 22));
+    assert!(graph.layers("layer2")?.has_edge(11, 44));
+
+    assert!(graph.edge(11, 22).is_some());
+    assert!(graph.layers(Layer::Default)?.edge(11, 44).is_none());
+    assert!(graph.layers("layer2")?.edge(11, 22).is_none());
+    assert!(graph.layers("layer2")?.edge(11, 44).is_some());
+
+    assert!(graph.exclude_layers("layer2")?.edge(11, 44).is_none());
+    assert!(graph.exclude_layers("layer2")?.edge(11, 33).is_some());
+    assert!(graph.exclude_layers("layer2")?.edge(11, 22).is_some());
+
+    let dft_layer = graph.default_layer();
+    let layer1 = graph.layers("layer1")?;
+    let layer2 = graph.layers("layer2")?;
+    assert!(graph.layers("missing layer").is_err());
+
+    assert_eq!(graph.count_nodes(), 4);
+    assert_eq!(graph.count_edges(), 4);
+    assert_eq!(dft_layer.count_edges(), 3);
+    assert_eq!(layer1.count_edges(), 1);
+    assert_eq!(layer2.count_edges(), 2);
+
+    let node = graph.node(11).unwrap();
+    let node_dft = dft_layer.node(11).unwrap();
+    let node1 = layer1.node(11).unwrap();
+    let node2 = layer2.node(11).unwrap();
+
+    assert_eq!(node.degree(), 3);
+    assert_eq!(node_dft.degree(), 2);
+    assert_eq!(node1.degree(), 1);
+    assert_eq!(node2.degree(), 2);
+
+    assert_eq!(node.out_degree(), 3);
+    assert_eq!(node_dft.out_degree(), 2);
+    assert_eq!(node1.out_degree(), 1);
+    assert_eq!(node2.out_degree(), 2);
+
+    assert_eq!(node.in_degree(), 1);
+    assert_eq!(node_dft.in_degree(), 1);
+    assert_eq!(node1.in_degree(), 0);
+    assert_eq!(node2.in_degree(), 0);
+
+    fn to_tuples<'graph, G: GraphViewOps<'graph>>(edges: Edges<'graph, G>) -> Vec<(u64, u64)> {
+        edges
+            .id()
+            .filter_map(|(s, d)| s.to_u64().zip(d.to_u64()))
+            .sorted()
+            .collect_vec()
+    }
 
-        assert!(graph
-            .exclude_layers("layer2")
-            .unwrap()
-            .edge(11, 44)
-            .is_none());
-        assert!(graph
-            .exclude_layers("layer2")
-            .unwrap()
-            .edge(11, 33)
-            .is_some());
-        assert!(graph
-            .exclude_layers("layer2")
-            .unwrap()
-            .edge(11, 22)
-            .is_some());
-
-        let dft_layer = graph.default_layer();
-        let layer1 = graph.layers("layer1").expect("layer1");
-        let layer2 = graph.layers("layer2").expect("layer2");
-        assert!(graph.layers("missing layer").is_err());
-
-        assert_eq!(graph.count_nodes(), 4);
-        assert_eq!(graph.count_edges(), 4);
-        assert_eq!(dft_layer.count_edges(), 3);
-        assert_eq!(layer1.count_edges(), 1);
-        assert_eq!(layer2.count_edges(), 2);
-
-        let node = graph.node(11).unwrap();
-        let node_dft = dft_layer.node(11).unwrap();
-        let node1 = layer1.node(11).unwrap();
-        let node2 = layer2.node(11).unwrap();
-
-        assert_eq!(node.degree(), 3);
-        assert_eq!(node_dft.degree(), 2);
-        assert_eq!(node1.degree(), 1);
-        assert_eq!(node2.degree(), 2);
-
-        assert_eq!(node.out_degree(), 3);
-        assert_eq!(node_dft.out_degree(), 2);
-        assert_eq!(node1.out_degree(), 1);
-        assert_eq!(node2.out_degree(), 2);
-
-        assert_eq!(node.in_degree(), 1);
-        assert_eq!(node_dft.in_degree(), 1);
-        assert_eq!(node1.in_degree(), 0);
-        assert_eq!(node2.in_degree(), 0);
-
-        fn to_tuples<'graph, G: GraphViewOps<'graph>>(edges: Edges<'graph, G>) -> Vec<(u64, u64)> {
-            edges
-                .id()
-                .filter_map(|(s, d)| s.to_u64().zip(d.to_u64()))
-                .sorted()
-                .collect_vec()
-        }
+    assert_eq!(
+        to_tuples(node.edges()),
+        vec![(11, 22), (11, 33), (11, 44), (33, 11)]
+    );
+    assert_eq!(
+        to_tuples(node_dft.edges()),
+        vec![(11, 22), (11, 33), (33, 11)]
+    );
+    assert_eq!(to_tuples(node1.edges()), vec![(11, 22)]);
+    assert_eq!(to_tuples(node2.edges()), vec![(11, 33), (11, 44)]);
 
-        assert_eq!(
-            to_tuples(node.edges()),
-            vec![(11, 22), (11, 33), (11, 44), (33, 11)]
-        );
-        assert_eq!(
-            to_tuples(node_dft.edges()),
-            vec![(11, 22), (11, 33), (33, 11)]
-        );
-        assert_eq!(to_tuples(node1.edges()), vec![(11, 22)]);
-        assert_eq!(to_tuples(node2.edges()), vec![(11, 33), (11, 44)]);
+    assert_eq!(to_tuples(node.in_edges()), vec![(33, 11)]);
+    assert_eq!(to_tuples(node_dft.in_edges()), vec![(33, 11)]);
+    assert_eq!(to_tuples(node1.in_edges()), vec![]);
+    assert_eq!(to_tuples(node2.in_edges()), vec![]);
 
-        assert_eq!(to_tuples(node.in_edges()), vec![(33, 11)]);
-        assert_eq!(to_tuples(node_dft.in_edges()), vec![(33, 11)]);
-        assert_eq!(to_tuples(node1.in_edges()), vec![]);
-        assert_eq!(to_tuples(node2.in_edges()), vec![]);
+    assert_eq!(
+        to_tuples(node.out_edges()),
+        vec![(11, 22), (11, 33), (11, 44)]
+    );
+    assert_eq!(to_tuples(node_dft.out_edges()), vec![(11, 22), (11, 33)]);
+    assert_eq!(to_tuples(node1.out_edges()), vec![(11, 22)]);
+    assert_eq!(to_tuples(node2.out_edges()), vec![(11, 33), (11, 44)]);
 
-        assert_eq!(
-            to_tuples(node.out_edges()),
-            vec![(11, 22), (11, 33), (11, 44)]
-        );
-        assert_eq!(to_tuples(node_dft.out_edges()), vec![(11, 22), (11, 33)]);
-        assert_eq!(to_tuples(node1.out_edges()), vec![(11, 22)]);
-        assert_eq!(to_tuples(node2.out_edges()), vec![(11, 33), (11, 44)]);
-
-        fn to_ids<'graph, G: GraphViewOps<'graph>>(
-            neighbours: PathFromNode<'graph, G>,
-        ) -> Vec<u64> {
-            neighbours
-                .iter()
-                .filter_map(|n| n.id().as_u64())
-                .sorted()
-                .collect_vec()
-        }
+    fn to_ids<'graph, G: GraphViewOps<'graph>>(neighbours: PathFromNode<'graph, G>) -> Vec<u64> {
+        neighbours
+            .iter()
+            .filter_map(|n| n.id().as_u64())
+            .sorted()
+            .collect_vec()
+    }
 
-        assert_eq!(to_ids(node.neighbours()), vec![22, 33, 44]);
-        assert_eq!(to_ids(node_dft.neighbours()), vec![22, 33]);
-        assert_eq!(to_ids(node1.neighbours()), vec![22]);
-        assert_eq!(to_ids(node2.neighbours()), vec![33, 44]);
+    assert_eq!(to_ids(node.neighbours()), vec![22, 33, 44]);
+    assert_eq!(to_ids(node_dft.neighbours()), vec![22, 33]);
+    assert_eq!(to_ids(node1.neighbours()), vec![22]);
+    assert_eq!(to_ids(node2.neighbours()), vec![33, 44]);
 
-        assert_eq!(to_ids(node.out_neighbours()), vec![22, 33, 44]);
-        assert_eq!(to_ids(node_dft.out_neighbours()), vec![22, 33]);
-        assert_eq!(to_ids(node1.out_neighbours()), vec![22]);
-        assert_eq!(to_ids(node2.out_neighbours()), vec![33, 44]);
+    assert_eq!(to_ids(node.out_neighbours()), vec![22, 33, 44]);
+    assert_eq!(to_ids(node_dft.out_neighbours()), vec![22, 33]);
+    assert_eq!(to_ids(node1.out_neighbours()), vec![22]);
+    assert_eq!(to_ids(node2.out_neighbours()), vec![33, 44]);
 
-        assert_eq!(to_ids(node.in_neighbours()), vec![33]);
-        assert_eq!(to_ids(node_dft.in_neighbours()), vec![33]);
-        assert!(to_ids(node1.in_neighbours()).is_empty());
-        assert!(to_ids(node2.in_neighbours()).is_empty());
-    });
+    assert_eq!(to_ids(node.in_neighbours()), vec![33]);
+    assert_eq!(to_ids(node_dft.in_neighbours()), vec![33]);
+    assert!(to_ids(node1.in_neighbours()).is_empty());
+    assert!(to_ids(node2.in_neighbours()).is_empty());
     Ok(())
 }
 
@@ -1658,17 +1737,18 @@ fn test_edge_earliest_latest() {
 
 #[test]
 fn node_properties() -> Result<(), GraphError> {
-    let g = Graph::new_with_shards(2);
+    let g = Graph::new();
 
     g.add_node(
         0,
         1,
         [("t", Prop::str("wallet")), ("cost", Prop::F64(99.5))],
         Some("a"),
+        None,
     )?;
 
     let n1 = g.node(1).unwrap();
-    g.add_node(1, 2, [("t", Prop::str("person"))], None)?;
+    g.add_node(1, 2, [("t", Prop::str("person"))], None, None)?;
     g.add_node(
         6,
         3,
@@ -1677,6 +1757,7 @@ fn node_properties() -> Result<(), GraphError> {
             ("cost_b", Prop::F64(76.0)),
         ],
         Some("b"),
+        None,
     )?;
 
     g.add_node(
@@ -1687,6 +1768,7 @@ fn node_properties() -> Result<(), GraphError> {
             ("bool_prop", Prop::Bool(true)),
         ],
         Some("b"),
+        None,
     )?;
 
     n1.add_metadata([("lol", Prop::str("smile"))])?;
@@ -1714,7 +1796,7 @@ fn test_decimal_properties() {
     let graph = Graph::new();
     let dec_prop = Prop::Decimal(BigDecimal::new(123456234234123123i64.into(), 9));
     graph
-        .add_node(0, 1, [("cost".to_string(), dec_prop.clone())], None)
+        .add_node(0, 1, [("cost".to_string(), dec_prop.clone())], None, None)
         .unwrap();
 
     test_storage!(&graph, |graph| {
@@ -1728,10 +1810,10 @@ fn test_decimal_properties() {
 fn node_history_rows() {
     let graph = Graph::new();
     graph
-        .add_node(1, 2, [("cool".to_string(), Prop::U64(1))], None)
+        .add_node(1, 2, [("cool".to_string(), Prop::U64(1))], None, None)
         .unwrap();
     graph
-        .add_node(0, 1, [("cool".to_string(), 1u64)], None)
+        .add_node(0, 1, [("cool".to_string(), 1u64)], None, None)
         .unwrap();
     graph
         .add_node(
@@ -1742,86 +1824,87 @@ fn node_history_rows() {
                 ("bla".to_string(), Prop::I64(2)),
             ],
             None,
+            None,
         )
         .unwrap();
-    graph.add_node(2, 1, NO_PROPS, None).unwrap();
+    graph.add_node(2, 1, NO_PROPS, None, None).unwrap();
     graph
-        .add_node(1, 1, [("cool".to_string(), 3u64)], None)
+        .add_node(1, 1, [("cool".to_string(), 3u64)], None, None)
         .unwrap();
 
-    test_storage!(&graph, |graph| {
-        let node = graph.node(1).unwrap();
+    let node = graph.node(1).unwrap();
 
-        let actual = node
-            .rows()
-            .map(|(t, row)| (t, row.into_iter().map(|(_, a)| a).collect::<Vec<_>>()))
-            .collect::<Vec<_>>();
+    let actual = node
+        .rows()
+        .map(|(t, _, row)| (t, row.into_iter().map(|(_, a)| a).collect::<Vec<_>>()))
+        .collect::<Vec<_>>();
 
-        let expected = vec![
-            (EventTime::new(0, 1), vec![Prop::U64(1)]),
-            (EventTime::new(1, 2), vec![Prop::Bool(true), Prop::I64(2)]),
-            (EventTime::new(1, 4), vec![Prop::U64(3)]),
-            (EventTime::new(2, 3), vec![]),
-        ];
+    let expected = vec![
+        (EventTime::new(0, 1), vec![Prop::U64(1)]),
+        (EventTime::new(1, 2), vec![Prop::Bool(true), Prop::I64(2)]),
+        (EventTime::new(1, 4), vec![Prop::U64(3)]),
+        (EventTime::new(2, 3), vec![]),
+    ];
 
-        assert_eq!(actual, expected);
+    assert_eq!(actual, expected);
 
-        let node = graph.node(2).unwrap();
+    let node = graph.node(2).unwrap();
 
-        let actual = node
-            .rows()
-            .map(|(t, row)| (t, row.into_iter().map(|(_, a)| a).collect::<Vec<_>>()))
-            .collect::<Vec<_>>();
+    let actual = node
+        .rows()
+        .map(|(t, _, row)| (t, row.into_iter().map(|(_, a)| a).collect::<Vec<_>>()))
+        .collect::<Vec<_>>();
 
-        let expected = vec![(EventTime::new(1, 0), vec![Prop::U64(1)])];
+    let expected = vec![(EventTime::new(1, 0), vec![Prop::U64(1)])];
 
-        assert_eq!(actual, expected);
-    });
+    assert_eq!(actual, expected);
 }
 
 #[test]
 fn check_node_history_str() {
     let graph = Graph::new();
 
-    graph.add_node(4, "Lord Farquaad", NO_PROPS, None).unwrap();
-    graph.add_node(6, "Lord Farquaad", NO_PROPS, None).unwrap();
-    graph.add_node(7, "Lord Farquaad", NO_PROPS, None).unwrap();
-    graph.add_node(8, "Lord Farquaad", NO_PROPS, None).unwrap();
+    graph
+        .add_node(4, "Lord Farquaad", NO_PROPS, None, None)
+        .unwrap();
+    graph
+        .add_node(6, "Lord Farquaad", NO_PROPS, None, None)
+        .unwrap();
+    graph
+        .add_node(7, "Lord Farquaad", NO_PROPS, None, None)
+        .unwrap();
+    graph
+        .add_node(8, "Lord Farquaad", NO_PROPS, None, None)
+        .unwrap();
 
-    // FIXME: Node updates without properties or edges are currently not supported in disk_graph (see issue #46)
-    test_graph(&graph, |graph| {
-        let times_of_farquaad = graph.node("Lord Farquaad").unwrap().history();
+    let times_of_farquaad = graph.node("Lord Farquaad").unwrap().history();
 
-        assert_eq!(times_of_farquaad, [4, 6, 7, 8]);
+    assert_eq!(times_of_farquaad, [4, 6, 7, 8]);
 
-        let view = graph.window(1, 8);
+    let view = graph.window(1, 8);
 
-        let windowed_times_of_farquaad = view.node("Lord Farquaad").unwrap().history();
-        assert_eq!(windowed_times_of_farquaad, [4, 6, 7]);
-    });
+    let windowed_times_of_farquaad = view.node("Lord Farquaad").unwrap().history();
+    assert_eq!(windowed_times_of_farquaad, [4, 6, 7]);
 }
 
 #[test]
 fn check_node_history_num() {
     let graph = Graph::new();
 
-    graph.add_node(1, 1, NO_PROPS, None).unwrap();
-    graph.add_node(2, 1, NO_PROPS, None).unwrap();
-    graph.add_node(3, 1, NO_PROPS, None).unwrap();
-    graph.add_node(4, 1, NO_PROPS, None).unwrap();
-    graph.add_node(8, 1, NO_PROPS, None).unwrap();
+    graph.add_node(1, 1, NO_PROPS, None, None).unwrap();
+    graph.add_node(2, 1, NO_PROPS, None, None).unwrap();
+    graph.add_node(3, 1, NO_PROPS, None, None).unwrap();
+    graph.add_node(4, 1, NO_PROPS, None, None).unwrap();
+    graph.add_node(8, 1, NO_PROPS, None, None).unwrap();
 
-    // FIXME: Node updates without properties or edges are currently not supported in disk_graph (see issue #46)
-    test_graph(&graph, |graph| {
-        let times_of_one = graph.node(1).unwrap().history();
+    let times_of_one = graph.node(1).unwrap().history();
 
-        assert_eq!(times_of_one, [1, 2, 3, 4, 8]);
+    assert_eq!(times_of_one, [1, 2, 3, 4, 8]);
 
-        let view = graph.window(1, 8);
+    let view = graph.window(1, 8);
 
-        let windowed_times_of_one = view.node(1).unwrap().history();
-        assert_eq!(windowed_times_of_one, [1, 2, 3, 4]);
-    });
+    let windowed_times_of_one = view.node(1).unwrap().history();
+    assert_eq!(windowed_times_of_one, [1, 2, 3, 4]);
 }
 
 #[test]
@@ -1832,17 +1915,15 @@ fn check_edge_history() {
     graph.add_edge(2, 1, 3, NO_PROPS, None).unwrap();
     graph.add_edge(3, 1, 2, NO_PROPS, None).unwrap();
     graph.add_edge(4, 1, 4, NO_PROPS, None).unwrap();
-    test_storage!(&graph, |graph| {
-        let times_of_onetwo = graph.edge(1, 2).unwrap().history();
-        let times_of_four = graph.edge(1, 4).unwrap().window(1, 5).history();
-        let view = graph.window(2, 5);
-        let windowed_times_of_four = view.edge(1, 4).unwrap().window(2, 4).history();
-
-        assert_eq!(times_of_onetwo, [1, 3]);
-        assert_eq!(times_of_four, [4]);
-        assert!(windowed_times_of_four.is_empty());
-        assert_eq!(graph.node(1).unwrap().edge_history_count(), 4);
-    });
+    let times_of_onetwo = graph.edge(1, 2).unwrap().history();
+    let times_of_four = graph.edge(1, 4).unwrap().window(1, 5).history();
+    let view = graph.window(2, 5);
+    let windowed_times_of_four = view.edge(1, 4).unwrap().window(2, 4).history();
+
+    assert_eq!(times_of_onetwo, [1, 3]);
+    assert_eq!(times_of_four, [4]);
+    assert!(windowed_times_of_four.is_empty());
+    assert_eq!(graph.node(1).unwrap().edge_history_count(), 4);
 }
 
 #[test]
@@ -1851,74 +1932,13 @@ fn check_node_edge_history_count() {
     graph.add_edge(0, 0, 1, NO_PROPS, None).unwrap();
     graph.add_edge(3, 0, 1, NO_PROPS, None).unwrap();
 
-    test_storage!(&graph, |graph| {
-        let node = graph.node(0).unwrap();
-        assert_eq!(node.edge_history_count(), 2);
-        assert_eq!(node.after(1).edge_history_count(), 1);
-        assert_eq!(node.after(3).edge_history_count(), 0);
-    });
+    let node = graph.node(0).unwrap();
+    assert_eq!(node.edge_history_count(), 2);
+    assert_eq!(node.after(1).edge_history_count(), 1);
+    assert_eq!(node.after(3).edge_history_count(), 0);
 }
 
-#[cfg(feature = "storage")]
-use raphtory::test_utils::test_disk_graph;
-use raphtory::test_utils::{build_graph, build_graph_strat, test_graph};
-#[cfg(feature = "storage")]
-use raphtory_storage::graph::edges::edge_storage_ops::EdgeStorageOps;
-#[cfg(feature = "storage")]
-#[test]
-fn edges_at_from_node_history() {
-    let graph = Graph::new();
-
-    graph.add_edge(1, 0, 1, [("bla", 10i32)], None).unwrap();
-    graph.add_edge(2, 0, 2, [("bla", 20)], None).unwrap();
-    graph.add_edge(1, 0, 1, [("bla", 30)], None).unwrap();
-    graph.add_edge(4, 0, 3, [("bla", 40)], None).unwrap();
-    test_disk_graph(&graph, |g| {
-        let node = g.node(0).unwrap();
-        let node = &node;
-        let mut actual = g
-            .edges()
-            .explode()
-            .into_iter()
-            .flat_map(|e| {
-                e.properties()
-                    .temporal()
-                    .get_by_id(0)
-                    .into_iter()
-                    .flat_map(|p| p.into_iter())
-            })
-            .collect::<Vec<_>>();
-        actual.sort_by_key(|(t, _)| *t);
-
-        let exploded_edges = node
-            .edge_history()
-            .map(|(timestamp, edge_layer_id)| {
-                let eref = g
-                    .core_edge(edge_layer_id.edge)
-                    .out_ref()
-                    .at(timestamp)
-                    .at_layer(edge_layer_id.layer());
-                eref
-            })
-            .collect::<Vec<_>>();
-
-        assert_eq!(exploded_edges.len(), 4);
-
-        let mut edge_props = exploded_edges
-            .into_iter()
-            .map(|e| EdgeView::new(&g, e))
-            .flat_map(|e| {
-                e.properties()
-                    .temporal()
-                    .get_by_id(0)
-                    .into_iter()
-                    .flat_map(|p| p.into_iter())
-            })
-            .collect::<Vec<_>>();
-        edge_props.sort_by_key(|(t, _)| *t);
-        assert_eq!(edge_props, actual);
-    });
-}
+use raphtory_storage::graph::nodes::node_storage_ops::NodeStorageOps;
 
 #[test]
 fn check_edge_history_on_multiple_shards() {
@@ -1935,23 +1955,21 @@ fn check_edge_history_on_multiple_shards() {
     graph.add_edge(9, 1, 4, NO_PROPS, None).unwrap();
     graph.add_edge(10, 1, 4, NO_PROPS, None).unwrap();
 
-    test_storage!(&graph, |graph| {
-        let times_of_onetwo = graph.edge(1, 2).unwrap().history();
-        let times_of_four = graph.edge(1, 4).unwrap().window(1, 5).history();
-        let times_of_outside_window = graph.edge(1, 4).unwrap().window(1, 4).history();
-        let times_of_four_higher = graph.edge(1, 4).unwrap().window(6, 11).history();
-
-        let view = graph.window(1, 11);
-        let windowed_times_of_four = view.edge(1, 4).unwrap().window(2, 5).history();
-        let windowed_times_of_four_higher = view.edge(1, 4).unwrap().window(8, 11).history();
-
-        assert_eq!(times_of_onetwo, [1, 3]);
-        assert_eq!(times_of_four, [4]);
-        assert_eq!(times_of_four_higher, [6, 7, 8, 9, 10]);
-        assert!(times_of_outside_window.is_empty());
-        assert_eq!(windowed_times_of_four, [4]);
-        assert_eq!(windowed_times_of_four_higher, [8, 9, 10]);
-    });
+    let times_of_onetwo = graph.edge(1, 2).unwrap().history();
+    let times_of_four = graph.edge(1, 4).unwrap().window(1, 5).history();
+    let times_of_outside_window = graph.edge(1, 4).unwrap().window(1, 4).history();
+    let times_of_four_higher = graph.edge(1, 4).unwrap().window(6, 11).history();
+
+    let view = graph.window(1, 11);
+    let windowed_times_of_four = view.edge(1, 4).unwrap().window(2, 5).history();
+    let windowed_times_of_four_higher = view.edge(1, 4).unwrap().window(8, 11).history();
+
+    assert_eq!(times_of_onetwo, [1, 3]);
+    assert_eq!(times_of_four, [4]);
+    assert_eq!(times_of_four_higher, [6, 7, 8, 9, 10]);
+    assert!(times_of_outside_window.is_empty());
+    assert_eq!(windowed_times_of_four, [4]);
+    assert_eq!(windowed_times_of_four_higher, [8, 9, 10]);
 }
 
 #[derive(Debug)]
@@ -1974,7 +1992,7 @@ fn test_ingesting_timestamps() {
     let latest_time = "2022-06-07 12:34:00".try_into_time().unwrap().t();
 
     let g = Graph::new();
-    g.add_node("2022-06-06T12:34:00.000", 0, NO_PROPS, None)
+    g.add_node("2022-06-06T12:34:00.000", 0, NO_PROPS, None, None)
         .unwrap();
     g.add_edge("2022-06-07T12:34:00", 1, 2, NO_PROPS, None)
         .unwrap();
@@ -1984,7 +2002,7 @@ fn test_ingesting_timestamps() {
     let g = Graph::new();
     let fmt = "%Y-%m-%d %H:%M";
 
-    g.add_node(CustomTime("2022-06-06 12:34", fmt), 0, NO_PROPS, None)
+    g.add_node(CustomTime("2022-06-06 12:34", fmt), 0, NO_PROPS, None, None)
         .unwrap();
     g.add_edge(CustomTime("2022-06-07 12:34", fmt), 1, 2, NO_PROPS, None)
         .unwrap();
@@ -2026,7 +2044,7 @@ fn test_prop_display_str() {
 }
 
 #[test]
-fn test_graph_metadata() {
+fn test_graph_metadata_proptest() {
     proptest!(|(u64_props: HashMap<String, u64>)| {
         let g = Graph::new();
 
@@ -2035,7 +2053,7 @@ fn test_graph_metadata() {
             .map(|(name, value)| (name, Prop::U64(value)))
             .collect::<Vec<_>>();
 
-    g.add_metadata(as_props.clone()).unwrap();
+        g.add_metadata(as_props.clone()).unwrap();
 
         let props_map = as_props.into_iter().collect::<HashMap<_, _>>();
 
@@ -2046,13 +2064,11 @@ fn test_graph_metadata() {
 }
 
 #[test]
-fn test_graph_metadata2() {
+fn test_graph_metadata() {
     let g = Graph::new();
 
-    let as_props: Vec<(&str, Prop)> = vec![(
-        "mylist",
-        Prop::List(Arc::from(vec![Prop::I64(1), Prop::I64(2)])),
-    )];
+    let as_props: Vec<(&str, Prop)> =
+        vec![("mylist", Prop::list(vec![Prop::I64(1), Prop::I64(2)]))];
 
     g.add_metadata(as_props.clone()).unwrap();
 
@@ -2079,10 +2095,63 @@ fn test_graph_metadata2() {
 
     assert_eq!(
         g.metadata().keys().collect::<HashSet<_>>(),
-        props_names.union(&props_names2).cloned().collect()
+        props_names
+            .union(&props_names2)
+            .cloned()
+            .collect::<HashSet<_>>()
     );
 }
 
+#[test]
+fn test_add_graph_metadata_with_existing_key_throws_error() {
+    let g = Graph::new();
+    g.add_metadata(vec![("style", Prop::str("red"))]).unwrap();
+
+    assert!(g.add_metadata(vec![("style", Prop::str("blue"))]).is_err());
+    assert_eq!(g.metadata().get("style").unwrap(), Prop::str("red")); // Value is unchanged
+}
+
+#[test]
+fn test_graph_metadata_with_maps() {
+    let g = Graph::new();
+
+    let style_with_size = Prop::map(vec![("fill", Prop::str("red")), ("size", Prop::I64(5))]);
+
+    let style_with_opacity = Prop::map(vec![
+        ("fill", Prop::str("red")),
+        ("opacity", Prop::F64(0.4)),
+    ]);
+
+    // Add first metadata and verify
+    g.add_metadata(vec![("style", style_with_size.clone())])
+        .unwrap();
+    let actual = g.metadata().get("style").unwrap();
+    assert_eq!(actual, style_with_size.clone());
+
+    // Update metadata and verify
+    g.update_metadata(vec![("style", style_with_opacity.clone())])
+        .unwrap();
+    let actual = g.metadata().get("style").unwrap();
+    assert_eq!(actual, style_with_opacity.clone());
+
+    // Add another metadata property and verify
+    let config = Prop::map(vec![
+        ("theme", Prop::str("dark")),
+        ("version", Prop::I64(2)),
+    ]);
+    g.add_metadata(vec![("config", config.clone())]).unwrap();
+    let actual_config = g.metadata().get("config").unwrap();
+    assert_eq!(actual_config, config.clone());
+
+    // Verify style is still the updated value
+    let actual_style = g.metadata().get("style").unwrap();
+    assert_eq!(actual_style, style_with_opacity.clone());
+
+    // Verify all metadata keys exist
+    let keys: Vec<_> = g.metadata().keys().sorted().collect();
+    assert_eq!(keys, vec!["config", "style"]);
+}
+
 #[test]
 fn test_graph_metadata_names() {
     proptest!(|(u64_props: HashMap<String, u64>)| {
@@ -2093,7 +2162,7 @@ fn test_graph_metadata_names() {
             .map(|(name, value)| (name.into(), Prop::U64(value)))
             .collect::<Vec<_>>();
 
-    g.add_metadata(as_props.clone()).unwrap();
+        g.add_metadata(as_props.clone()).unwrap();
 
         let props_names = as_props
             .into_iter()
@@ -2108,73 +2177,134 @@ fn test_graph_metadata_names() {
 fn test_graph_temporal_props() {
     proptest!(|(str_props: HashMap<String, String>)| {
         global_info_logger();
-        let g = Graph::new();
 
+        let g = Graph::new();
         let (t0, t1) = (1, 2);
 
-        let (t0_props, t1_props): (Vec<_>, Vec<_>) = str_props
-            .iter()
-            .enumerate()
-            .map(|(i, props)| {
-                let (name, value) = props;
-                let value = Prop::from(value);
-                (name.as_str().into(), value, i % 2)
-            })
-            .partition(|(_, _, i)| *i == 0);
+        // Split properties into two sets based on even/odd index
+        // Even-indexed properties go to t0, odd-indexed to t1
+        let mut t0_props = HashMap::new();
+        let mut t1_props = HashMap::new();
 
-        let t0_props: HashMap<ArcStr, Prop> = t0_props
-            .into_iter()
-            .map(|(name, value, _)| (name, value))
-            .collect();
+        for (i, (name, value)) in str_props.iter().enumerate() {
+            let prop_name: ArcStr = name.as_str().into();
+            let prop_value = Prop::from(value.as_str());
 
-        let t1_props: HashMap<ArcStr, Prop> = t1_props
-            .into_iter()
-            .map(|(name, value, _)| (name, value))
-            .collect();
+            if i % 2 == 0 {
+                t0_props.insert(prop_name, prop_value);
+            } else {
+                t1_props.insert(prop_name, prop_value);
+            }
+        }
 
         g.add_properties(t0, t0_props.clone()).unwrap();
         g.add_properties(t1, t1_props.clone()).unwrap();
 
-        let check = t0_props.iter().all(|(name, value)| {
-            g.properties().temporal().get(name).unwrap().at(t0) == Some(value.clone())
-        }) && t1_props.iter().all(|(name, value)| {
-            g.properties().temporal().get(name).unwrap().at(t1) == Some(value.clone())
-        });
-        if !check {
-            error!("failed time-specific comparison for {:?}", str_props);
-            prop_assert!(false);
+        // Verify properties can be retrieved at their timestamps
+        for (name, expected_value) in t0_props.iter() {
+            let actual = g.properties().temporal().get(name).unwrap().at(t0);
+
+            prop_assert_eq!(
+                actual,
+                Some(expected_value.clone()),
+                "Property '{}' at t0 has wrong value",
+                name
+            );
+        }
+
+        for (name, expected_value) in t1_props.iter() {
+            let actual_value = g.properties().temporal().get(name).unwrap().at(t1);
+
+            prop_assert_eq!(
+                actual_value,
+                Some(expected_value.clone()),
+                "Property '{}' at t1 has wrong value",
+                name
+            );
         }
-        let check = check
-            && g.at(t0)
+
+        // Verify iter_latest returns all t0 properties
+        let actual_t0_props: HashMap<_, _> = g
+            .at(t0)
+            .properties()
+            .temporal()
+            .iter_latest()
+            .map(|(prop_name, prop_value)| (prop_name.clone(), prop_value))
+            .collect();
+
+        prop_assert_eq!(
+            actual_t0_props,
+            t0_props,
+            "iter_latest() at t0 returned wrong properties"
+        );
+
+        // Verify latest returns correct values for t1 properties
+        for (name, expected_value) in t1_props.iter() {
+            let actual = g
+                .at(t1)
                 .properties()
                 .temporal()
-                .iter_latest()
-                .map(|(k, v)| (k.clone(), v))
-                .collect::<HashMap<_, _, _>>()
-                == t0_props;
-        if !check {
-            error!("failed latest value comparison for {:?} at t0", str_props);
-            prop_assert!(false);
-        }
-        let check = check
-            && t1_props.iter().all(|(k, ve)| {
-                g.at(t1)
-                    .properties()
-                    .temporal()
-                    .get(k)
-                    .and_then(|v| v.latest())
-                    == Some(ve.clone())
-            });
-        if !check {
-            error!("failed latest value comparison for {:?} at t1", str_props);
-            prop_assert!(false);
+                .get(name)
+                .and_then(|v| v.latest());
+
+            prop_assert_eq!(
+                actual,
+                Some(expected_value.clone()),
+                "Property '{}' latest() at t1 has wrong value",
+                name
+            );
         }
-        prop_assert!(check);
     });
 }
 
 #[test]
-fn test_temporral_edge_props_window() {
+fn test_graph_temporal_props_with_maps() {
+    let g = Graph::new();
+
+    let style_with_size = Prop::map(vec![("fill", Prop::str("red")), ("size", Prop::I64(5))]);
+
+    let style_with_opacity = Prop::map(vec![
+        ("fill", Prop::str("red")),
+        ("opacity", Prop::F64(0.4)),
+    ]);
+
+    // Add temporal properties with nested maps at different timestamps
+    g.add_properties(0, vec![("style", style_with_size.clone())])
+        .unwrap();
+    g.add_properties(1, vec![("style", style_with_opacity.clone())])
+        .unwrap();
+    g.add_properties(2, vec![("style", style_with_size.clone())])
+        .unwrap();
+    g.add_properties(3, vec![("style", style_with_opacity.clone())])
+        .unwrap();
+
+    // Verify properties can be retrieved at their timestamps
+    let actual_t0 = g.properties().temporal().get("style").unwrap().at(0);
+    assert_eq!(actual_t0, Some(style_with_size.clone()));
+
+    let actual_t1 = g.properties().temporal().get("style").unwrap().at(1);
+    assert_eq!(actual_t1, Some(style_with_opacity.clone()));
+
+    let actual_t2 = g.properties().temporal().get("style").unwrap().at(2);
+    assert_eq!(actual_t2, Some(style_with_size.clone()));
+
+    let actual_t3 = g.properties().temporal().get("style").unwrap().at(3);
+    assert_eq!(actual_t3, Some(style_with_opacity.clone()));
+
+    // Verify history returns all timestamps
+    let history: Vec<_> = g
+        .properties()
+        .temporal()
+        .get("style")
+        .unwrap()
+        .history()
+        .collect();
+
+    assert_eq!(history, vec![0, 1, 2, 3]);
+}
+
+#[test]
+fn test_temporal_edge_props_window() {
     let graph = Graph::new();
     graph
         .add_edge(1, 1, 2, vec![("weight".to_string(), Prop::I64(1))], None)
@@ -2213,61 +2343,53 @@ fn test_temporral_edge_props_window() {
 #[test]
 fn test_node_early_late_times() {
     let graph = Graph::new();
-    graph.add_node(1, 1, NO_PROPS, None).unwrap();
-    graph.add_node(2, 1, NO_PROPS, None).unwrap();
-    graph.add_node(3, 1, NO_PROPS, None).unwrap();
+    graph.add_node(1, 1, NO_PROPS, None, None).unwrap();
+    graph.add_node(2, 1, NO_PROPS, None, None).unwrap();
+    graph.add_node(3, 1, NO_PROPS, None, None).unwrap();
 
     // FIXME: Node add without properties not showing up (Issue #46)
-    test_graph(&graph, |graph| {
-        assert_eq!(graph.node(1).unwrap().earliest_time().unwrap().t(), 1);
-        assert_eq!(graph.node(1).unwrap().latest_time().unwrap().t(), 3);
+    assert_eq!(graph.node(1).unwrap().earliest_time().unwrap().t(), 1);
+    assert_eq!(graph.node(1).unwrap().latest_time().unwrap().t(), 3);
 
-        assert_eq!(graph.at(2).node(1).unwrap().earliest_time().unwrap().t(), 2);
-        assert_eq!(graph.at(2).node(1).unwrap().latest_time().unwrap().t(), 2);
+    assert_eq!(graph.at(2).node(1).unwrap().earliest_time().unwrap().t(), 2);
+    assert_eq!(graph.at(2).node(1).unwrap().latest_time().unwrap().t(), 2);
 
-        assert_eq!(
-            graph
-                .before(2)
-                .node(1)
-                .unwrap()
-                .earliest_time()
-                .unwrap()
-                .t(),
-            1
-        );
-        assert_eq!(
-            graph.before(2).node(1).unwrap().latest_time().unwrap().t(),
-            1
-        );
+    assert_eq!(
+        graph
+            .before(2)
+            .node(1)
+            .unwrap()
+            .earliest_time()
+            .unwrap()
+            .t(),
+        1
+    );
+    assert_eq!(
+        graph.before(2).node(1).unwrap().latest_time().unwrap().t(),
+        1
+    );
 
-        assert_eq!(
-            graph.after(2).node(1).unwrap().earliest_time().unwrap().t(),
-            3
-        );
-        assert_eq!(
-            graph.after(2).node(1).unwrap().latest_time().unwrap().t(),
-            3
-        );
-    })
+    assert_eq!(
+        graph.after(2).node(1).unwrap().earliest_time().unwrap().t(),
+        3
+    );
+    assert_eq!(
+        graph.after(2).node(1).unwrap().latest_time().unwrap().t(),
+        3
+    );
 }
 
 #[test]
 fn test_node_ids() {
     let graph = Graph::new();
-    graph.add_node(1, 1, NO_PROPS, None).unwrap();
-    graph.add_node(1, 2, NO_PROPS, None).unwrap();
-    graph.add_node(2, 3, NO_PROPS, None).unwrap();
+    graph.add_node(1, 1, NO_PROPS, None, None).unwrap();
+    graph.add_node(1, 2, NO_PROPS, None, None).unwrap();
+    graph.add_node(2, 3, NO_PROPS, None, None).unwrap();
 
-    // FIXME: Node add without properties not showing up (Issue #46)
-    test_graph(&graph, |graph| {
-        assert_eq!(
-            graph.nodes().id().collect::<Vec<_>>(),
-            vec![1u64, 2u64, 3u64]
-        );
+    assert_eq!(graph.nodes().id().sort_by_id(), vec![1u64, 2u64, 3u64]);
 
-        let g_at = graph.at(1);
-        assert_eq!(g_at.nodes().id().collect::<Vec<_>>(), vec![1u64, 2u64]);
-    });
+    let g_at = graph.at(1);
+    assert_eq!(g_at.nodes().id().sort_by_id(), vec![1u64, 2u64]);
 }
 
 #[test]
@@ -2397,7 +2519,14 @@ fn test_layer_explode() {
             })
             .collect::<Vec<_>>();
 
-        assert_eq!(layer_exploded, vec![(1, 2, 0), (1, 2, 1), (1, 2, 2)]);
+        assert_eq!(
+            layer_exploded,
+            vec![
+                (1u64, 2u64, LayerId(1)),
+                (1u64, 2u64, LayerId(2)),
+                (1u64, 2u64, LayerId(3)),
+            ]
+        );
     });
 }
 
@@ -2514,9 +2643,9 @@ fn test_layer_explode_stacking_window() {
 #[test]
 fn test_multi_layer_degree() {
     let graph = Graph::new();
-    graph.add_node(1, 2, NO_PROPS, None).unwrap();
-    graph.add_node(1, 3, NO_PROPS, None).unwrap();
-    graph.add_node(1, 4, NO_PROPS, None).unwrap();
+    graph.add_node(1, 2, NO_PROPS, None, None).unwrap();
+    graph.add_node(1, 3, NO_PROPS, None, None).unwrap();
+    graph.add_node(1, 4, NO_PROPS, None, None).unwrap();
 
     graph.add_edge(1, 1, 4, NO_PROPS, None).expect("failed");
     graph
@@ -2655,7 +2784,7 @@ fn node_from_id_is_consistent() {
     proptest!(|(nodes: Vec<u64>)| {
         let g = Graph::new();
         for v in nodes.iter() {
-            g.add_node(0, *v, NO_PROPS, None).unwrap();
+            g.add_node(0, *v, NO_PROPS, None, None).unwrap();
         }
         prop_assert!(g.nodes()
             .name()
@@ -2669,7 +2798,8 @@ fn node_from_id_is_consistent() {
 fn large_id_is_consistent() {
     global_info_logger();
     let g = Graph::new();
-    g.add_node(0, 10000000000000000006, NO_PROPS, None).unwrap();
+    g.add_node(0, 10000000000000000006, NO_PROPS, None, None)
+        .unwrap();
     info!("names: {:?}", g.nodes().name().collect_vec());
     assert!(g
         .nodes()
@@ -2793,6 +2923,40 @@ fn can_apply_algorithm_on_filtered_graph() {
     });
 }
 
+#[test]
+fn test_node_state_merge() {
+    let graph = Graph::new();
+    for i in 0..1_000 {
+        graph.add_edge(0, i, i + 1, NO_PROPS, None).unwrap();
+    }
+
+    let sg = graph.subgraph(1..200);
+    let degs = degree_centrality(&graph);
+    let pr = unweighted_page_rank(&sg, None, None, None, false, None);
+
+    let m1 = pr.state.merge(
+        &degs.state,
+        MergePriority::Left,
+        MergePriority::Left,
+        Some(HashMap::from([(
+            "degree_centrality".to_string(),
+            MergePriority::Right,
+        )])),
+    );
+    assert_eq!(m1.values().num_rows(), sg.count_nodes());
+
+    let m2 = degs.state.merge(
+        &pr.state,
+        MergePriority::Left,
+        MergePriority::Left,
+        Some(HashMap::from([(
+            "pagerank_score".to_string(),
+            MergePriority::Right,
+        )])),
+    );
+    assert_eq!(m2.values().num_rows(), graph.count_nodes());
+}
+
 #[test]
 #[cfg(feature = "proto")]
 fn save_load_serial() {
@@ -2801,18 +2965,18 @@ fn save_load_serial() {
     let dir = tempfile::tempdir().unwrap();
     let file_path = dir.path().join("abcd11");
     g.encode(&file_path).unwrap();
-    let gg = Graph::decode(file_path).unwrap();
+    let gg = Graph::decode(&file_path).unwrap();
     assert_graph_equal(&g, &gg);
 }
 
 #[test]
 fn test_node_type_changes() {
     let g = Graph::new();
-    g.add_node(0, "A", NO_PROPS, Some("typeA")).unwrap();
-    g.add_node(1, "A", NO_PROPS, None).unwrap();
+    g.add_node(0, "A", NO_PROPS, Some("typeA"), None).unwrap();
+    g.add_node(1, "A", NO_PROPS, None, None).unwrap();
     let node_a = g.node("A").unwrap();
     assert_eq!(node_a.node_type().as_str(), Some("typeA"));
-    let result = g.add_node(2, "A", NO_PROPS, Some("typeB"));
+    let result = g.add_node(2, "A", NO_PROPS, Some("typeB"), None);
     assert!(result.is_err());
 }
 
@@ -2852,30 +3016,31 @@ fn test_layer_name() {
 fn test_type_filter() {
     let g = PersistentGraph::new();
 
-    g.add_node(1, 1, NO_PROPS, Some("wallet")).unwrap();
-    g.add_node(1, 2, NO_PROPS, Some("timer")).unwrap();
-    g.add_node(1, 3, NO_PROPS, Some("timer")).unwrap();
-    g.add_node(1, 4, NO_PROPS, Some("wallet")).unwrap();
+    g.add_node(1, 1, NO_PROPS, Some("wallet"), None).unwrap();
+    g.add_node(1, 2, NO_PROPS, Some("timer"), None).unwrap();
+    g.add_node(1, 3, NO_PROPS, Some("timer"), None).unwrap();
+    g.add_node(1, 4, NO_PROPS, Some("wallet"), None).unwrap();
 
     assert_eq!(
         g.nodes()
             .type_filter(["wallet"])
             .name()
             .into_iter_values()
+            .sorted()
             .collect_vec(),
         vec!["1", "4"]
     );
 
     let g = Graph::new();
-    g.add_node(1, 1, NO_PROPS, Some("a")).unwrap();
-    g.add_node(1, 2, NO_PROPS, Some("b")).unwrap();
-    g.add_node(1, 3, NO_PROPS, Some("b")).unwrap();
-    g.add_node(1, 4, NO_PROPS, Some("a")).unwrap();
-    g.add_node(1, 5, NO_PROPS, Some("c")).unwrap();
-    g.add_node(1, 6, NO_PROPS, Some("e")).unwrap();
-    g.add_node(1, 7, NO_PROPS, None).unwrap();
-    g.add_node(1, 8, NO_PROPS, None).unwrap();
-    g.add_node(1, 9, NO_PROPS, None).unwrap();
+    g.add_node(1, 1, NO_PROPS, Some("a"), None).unwrap();
+    g.add_node(1, 2, NO_PROPS, Some("b"), None).unwrap();
+    g.add_node(1, 3, NO_PROPS, Some("b"), None).unwrap();
+    g.add_node(1, 4, NO_PROPS, Some("a"), None).unwrap();
+    g.add_node(1, 5, NO_PROPS, Some("c"), None).unwrap();
+    g.add_node(1, 6, NO_PROPS, Some("e"), None).unwrap();
+    g.add_node(1, 7, NO_PROPS, None, None).unwrap();
+    g.add_node(1, 8, NO_PROPS, None, None).unwrap();
+    g.add_node(1, 9, NO_PROPS, None, None).unwrap();
     g.add_edge(2, 1, 2, NO_PROPS, Some("a")).unwrap();
     g.add_edge(2, 3, 2, NO_PROPS, Some("a")).unwrap();
     g.add_edge(2, 2, 4, NO_PROPS, Some("a")).unwrap();
@@ -2888,30 +3053,23 @@ fn test_type_filter() {
         g.nodes()
             .type_filter(["a", "b", "c", "e"])
             .name()
-            .collect_vec(),
+            .sort_by_values(false),
         vec!["1", "2", "3", "4", "5", "6"]
     );
 
     assert_eq!(
-        g.nodes()
-            .type_filter(Vec::<String>::new())
-            .name()
-            .collect_vec(),
+        g.nodes().type_filter(Vec::<String>::new()).name(),
         Vec::<String>::new()
     );
 
     assert_eq!(
-        g.nodes().type_filter([""]).name().collect_vec(),
+        g.nodes().type_filter([""]).name().sort_by_values(false),
         vec!["7", "8", "9"]
     );
 
     let w = g.window(1, 4);
     assert_eq!(
-        w.nodes()
-            .type_filter(["a"])
-            .iter()
-            .map(|v| v.degree())
-            .collect::<Vec<_>>(),
+        w.nodes().type_filter(["a"]).degree().sort_by_id(),
         vec![1, 2]
     );
     assert_eq!(
@@ -2920,18 +3078,15 @@ fn test_type_filter() {
             .neighbours()
             .type_filter(["c", "b"])
             .name()
-            .map(|n| { n.collect::<Vec<_>>() })
+            .sorted_by_key(|(n, _)| n.id())
+            .map(|(_, v)| v.sorted().collect::<Vec<_>>())
             .collect_vec(),
         vec![vec!["2"], vec!["2", "5"]]
     );
 
     let l = g.layers(["a"]).unwrap();
     assert_eq!(
-        l.nodes()
-            .type_filter(["a"])
-            .iter()
-            .map(|v| v.degree())
-            .collect::<Vec<_>>(),
+        l.nodes().type_filter(["a"]).degree().sort_by_id(),
         vec![1, 2]
     );
     assert_eq!(
@@ -2940,18 +3095,15 @@ fn test_type_filter() {
             .neighbours()
             .type_filter(["c", "b"])
             .name()
-            .map(|n| { n.collect::<Vec<_>>() })
+            .sorted_by_key(|(n, _)| n.id())
+            .map(|(_, v)| v.sorted().collect::<Vec<_>>())
             .collect_vec(),
         vec![vec!["2"], vec!["2", "5"]]
     );
 
     let sg = g.subgraph([1, 2, 3, 4, 5, 6]);
     assert_eq!(
-        sg.nodes()
-            .type_filter(["a"])
-            .iter()
-            .map(|v| v.degree())
-            .collect::<Vec<_>>(),
+        sg.nodes().type_filter(["a"]).degree().sort_by_id(),
         vec![1, 2]
     );
     assert_eq!(
@@ -2960,37 +3112,34 @@ fn test_type_filter() {
             .neighbours()
             .type_filter(["c", "b"])
             .name()
-            .map(|n| { n.collect::<Vec<_>>() })
+            .sorted_by_key(|(n, _)| n.id())
+            .map(|(_, v)| v.sorted().collect_vec())
             .collect_vec(),
         vec![vec!["2"], vec!["2", "5"]]
     );
 
     assert_eq!(
-        g.nodes().iter().map(|v| v.degree()).collect::<Vec<_>>(),
+        g.nodes().degree().sort_by_id(),
         vec![1, 3, 2, 2, 2, 2, 0, 0, 0]
     );
     assert_eq!(
-        g.nodes()
-            .type_filter(["a"])
-            .iter()
-            .map(|v| v.degree())
-            .collect::<Vec<_>>(),
+        g.nodes().type_filter(["a"]).degree().sort_by_id(),
         vec![1, 2]
     );
     assert_eq!(
-        g.nodes()
-            .type_filter(["d"])
-            .iter()
-            .map(|v| v.degree())
-            .collect::<Vec<_>>(),
+        g.nodes().type_filter(["d"]).degree().sort_by_id(),
         Vec::<usize>::new()
     );
     assert_eq!(
         g.nodes()
             .type_filter(["a"])
             .par_iter()
-            .map(|v| v.degree())
-            .collect::<Vec<_>>(),
+            .map(|v| (v, v.degree()))
+            .collect::<Vec<_>>()
+            .into_iter()
+            .sorted_by_key(|(n, _)| n.id())
+            .map(|(_, v)| v)
+            .collect_vec(),
         vec![1, 2]
     );
     assert_eq!(
@@ -3008,6 +3157,9 @@ fn test_type_filter() {
             .collect()
             .into_iter()
             .map(|n| n.name())
+            .collect_vec()
+            .into_iter()
+            .sorted()
             .collect_vec(),
         vec!["1", "4"]
     );
@@ -3041,6 +3193,7 @@ fn test_type_filter() {
             .type_filter(["a", "c"])
             .name()
             .into_iter_values()
+            .sorted()
             .collect_vec(),
         vec!["1", "4", "5"]
     );
@@ -3050,7 +3203,8 @@ fn test_type_filter() {
             .type_filter(["a"])
             .neighbours()
             .name()
-            .map(|n| { n.collect::<Vec<_>>() })
+            .sorted_by_key(|(n, _)| n.id())
+            .map(|(_, v)| v.sorted().collect::<Vec<_>>())
             .collect_vec(),
         vec![vec!["2"], vec!["2", "5"]]
     );
@@ -3059,7 +3213,8 @@ fn test_type_filter() {
             .type_filter(["a", "c"])
             .neighbours()
             .name()
-            .map(|n| { n.collect::<Vec<_>>() })
+            .sorted_by_key(|(n, _)| n.id())
+            .map(|(_, v)| v.sorted().collect::<Vec<_>>())
             .collect_vec(),
         vec![vec!["2"], vec!["2", "5"], vec!["4", "6"]]
     );
@@ -3068,7 +3223,7 @@ fn test_type_filter() {
             .type_filter(["d"])
             .neighbours()
             .name()
-            .map(|n| { n.collect::<Vec<_>>() })
+            .map(|(_, n)| n.collect_vec())
             .collect_vec(),
         Vec::<Vec<&str>>::new()
     );
@@ -3079,7 +3234,8 @@ fn test_type_filter() {
             .neighbours()
             .type_filter(["c"])
             .name()
-            .map(|n| { n.collect::<Vec<_>>() })
+            .sorted_by_key(|(n, _)| n.id())
+            .map(|(_, v)| v.collect::<Vec<_>>())
             .collect_vec(),
         vec![vec![], vec!["5"]]
     );
@@ -3089,7 +3245,7 @@ fn test_type_filter() {
             .neighbours()
             .type_filter(Vec::<&str>::new())
             .name()
-            .map(|n| { n.collect::<Vec<_>>() })
+            .map(|(_, n)| { n.collect::<Vec<_>>() })
             .collect_vec(),
         vec![vec![], Vec::<&str>::new()]
     );
@@ -3099,7 +3255,8 @@ fn test_type_filter() {
             .neighbours()
             .type_filter(["c", "b"])
             .name()
-            .map(|n| { n.collect::<Vec<_>>() })
+            .sorted_by_key(|(n, _)| n.id())
+            .map(|(_, v)| v.sorted().collect::<Vec<_>>())
             .collect_vec(),
         vec![vec!["2"], vec!["2", "5"]]
     );
@@ -3109,7 +3266,7 @@ fn test_type_filter() {
             .neighbours()
             .type_filter(["d"])
             .name()
-            .map(|n| { n.collect::<Vec<_>>() })
+            .map(|(_, n)| { n.collect::<Vec<_>>() })
             .collect_vec(),
         vec![vec![], Vec::<&str>::new()]
     );
@@ -3120,7 +3277,8 @@ fn test_type_filter() {
             .neighbours()
             .neighbours()
             .name()
-            .map(|n| { n.collect::<Vec<_>>() })
+            .sorted_by_key(|(n, _)| n.id())
+            .map(|(_, v)| v.sorted().collect::<Vec<_>>())
             .collect_vec(),
         vec![vec!["1", "3", "4"], vec!["1", "3", "4", "4", "6"]]
     );
@@ -3132,7 +3290,8 @@ fn test_type_filter() {
             .type_filter(["c"])
             .neighbours()
             .name()
-            .map(|n| { n.collect::<Vec<_>>() })
+            .sorted_by_key(|(n, _)| n.id())
+            .map(|(_, v)| v.sorted().collect::<Vec<_>>())
             .collect_vec(),
         vec![vec![], vec!["4", "6"]]
     );
@@ -3142,15 +3301,16 @@ fn test_type_filter() {
             .neighbours()
             .neighbours()
             .name()
-            .map(|n| { n.collect::<Vec<_>>() })
+            .sorted_by_key(|(n, _)| n.id())
+            .map(|(_, v)| v.sorted().collect::<Vec<_>>())
             .collect_vec(),
         vec![
             vec!["1", "3", "4"],
-            vec!["2", "2", "6", "2", "5"],
-            vec!["1", "3", "4", "3", "5"],
+            vec!["2", "2", "2", "5", "6"],
+            vec!["1", "3", "3", "4", "5"],
             vec!["1", "3", "4", "4", "6"],
-            vec!["2", "5", "3", "5"],
-            vec!["2", "6", "4", "6"],
+            vec!["2", "3", "5", "5"],
+            vec!["2", "4", "6", "6"],
             vec![],
             vec![],
             vec![],
@@ -3179,7 +3339,7 @@ fn test_type_filter() {
             .neighbours()
             .type_filter(["d"])
             .iter()
-            .map(|n| { n.name().collect::<Vec<_>>() })
+            .map(|(_, n)| { n.name().collect::<Vec<_>>() })
             .collect_vec(),
         vec![vec![], Vec::<&str>::new()]
     );
@@ -3211,7 +3371,12 @@ fn test_type_filter() {
     );
 
     assert_eq!(
-        g.node("2").unwrap().neighbours().name().collect_vec(),
+        g.node("2")
+            .unwrap()
+            .neighbours()
+            .name()
+            .sorted()
+            .collect_vec(),
         vec!["1", "3", "4"]
     );
 
@@ -3241,6 +3406,7 @@ fn test_type_filter() {
             .neighbours()
             .type_filter(["c", "a"])
             .name()
+            .sorted()
             .collect_vec(),
         vec!["1", "4"]
     );
@@ -3262,8 +3428,9 @@ fn test_type_filter() {
             .neighbours()
             .neighbours()
             .name()
+            .sorted()
             .collect_vec(),
-        vec!["2", "2", "6", "2", "5"],
+        vec!["2", "2", "2", "5", "6"],
     );
 
     assert_eq!(
@@ -3430,20 +3597,10 @@ fn test_unique_property() {
     );
 }
 
-#[test]
-fn num_locks_same_as_threads() {
-    let pool = rayon::ThreadPoolBuilder::new()
-        .num_threads(5)
-        .build()
-        .unwrap();
-    let graph = pool.install(Graph::new);
-    assert_eq!(graph.core_graph().unfiltered_num_nodes(), 0);
-}
-
 #[test]
 fn test_create_node() {
     let g = Graph::new();
-    g.create_node(0, 1, [("test", Prop::Bool(true))], None)
+    g.create_node(0, 1, [("test", Prop::Bool(true))], None, None)
         .unwrap();
 
     let n = g.node(1).unwrap();
@@ -3451,7 +3608,7 @@ fn test_create_node() {
     assert_eq!(n.id().as_u64().unwrap(), 1);
     assert_eq!(n.properties().get("test").unwrap(), Prop::Bool(true));
 
-    let result = g.create_node(1, 1, [("test".to_string(), Prop::Bool(true))], None);
+    let result = g.create_node(1, 1, [("test".to_string(), Prop::Bool(true))], None, None);
     assert!(matches!(result, Err(GraphError::NodeExistsError(id)) if id == GID::U64(1)));
 }
 
@@ -3481,7 +3638,7 @@ fn test_id_filter() {
 
 #[test]
 fn test_indexed() {
-    proptest!(|(graph in build_graph_strat(10, 10, false), nodes in subsequence((0..10).collect::<Vec<_>>(), 0..10))| {
+    proptest!(|(graph in build_graph_strat(10, 10, 10, 10, false), nodes in subsequence((0..10).collect::<Vec<_>>(), 0..10))| {
         let graph = Graph::from(build_graph(&graph));
         let expected_node_ids = nodes.iter().copied().filter(|&id| graph.has_node(id)).collect::<Vec<_>>();
         let nodes = graph.nodes().id_filter(nodes);
@@ -3491,7 +3648,7 @@ fn test_indexed() {
 
 #[test]
 fn materialize_window_prop_test() {
-    proptest!(|(graph_f in build_graph_strat(10, 10, true), w in any::<Range<i64>>())| {
+    proptest!(|(graph_f in build_graph_strat(10, 10, 10, 10, true), w in any::<Range<i64>>())| {
         let g = Graph::from(build_graph(&graph_f));
         let gw = g.window(w.start, w.end);
         let gmw = gw.materialize().unwrap();
@@ -3499,6 +3656,118 @@ fn materialize_window_prop_test() {
     })
 }
 
+#[test]
+fn materialize_temporal_properties_one_edge() {
+    let g = Graph::new();
+    g.add_edge(
+        0,
+        0,
+        0,
+        [("3", Prop::I64(1)), ("0", Prop::str("baa"))],
+        Some("a"),
+    )
+    .unwrap();
+
+    let gw = g.window(-9, 3);
+    let gmw = gw.materialize().unwrap();
+    assert_graph_equal(&gw, &gmw);
+}
+
+#[test]
+fn materialize_one_node() {
+    let g = Graph::new();
+    g.add_node(0, 0, NO_PROPS, None, None).unwrap();
+
+    let n = g.node(0).unwrap();
+    let hist = n.history();
+    assert!(!hist.is_empty());
+    let rows = n.rows().collect::<Vec<_>>();
+    assert!(!rows.is_empty());
+
+    let gw = g.window(0, 1);
+    let gmw = gw.materialize().unwrap();
+
+    assert_graph_equal(&gw, &gmw);
+}
+
+#[test]
+fn materialize_some_edges() -> Result<(), GraphError> {
+    let edges1_props = EdgeUpdatesFixture {
+        props: PropUpdatesFixture {
+            t_props: vec![
+                (2433054617899119663, vec![]),
+                (
+                    5623371002478468619,
+                    vec![("0".to_owned(), Prop::I64(-180204069376666762))],
+                ),
+            ],
+            c_props: vec![],
+        },
+        deletions: vec![-3684372592923241629, 3668280323305195349],
+    };
+
+    let edges2_props = EdgeUpdatesFixture {
+        props: PropUpdatesFixture {
+            t_props: vec![
+                (
+                    -7888823724540213280,
+                    vec![("0".to_owned(), Prop::I64(1339447446033500001))],
+                ),
+                (-3792330935693192039, vec![]),
+                (
+                    4049942931077033460,
+                    vec![("0".to_owned(), Prop::I64(-544773539725842277))],
+                ),
+                (5085404190610173488, vec![]),
+                (1445770503123270290, vec![]),
+                (-5628624083683143619, vec![]),
+                (-394401628579820652, vec![]),
+                (-2398199704888544233, vec![]),
+            ],
+            c_props: vec![("0".to_owned(), Prop::I64(-1877019573933389749))],
+        },
+        deletions: vec![
+            3969804007878301015,
+            7040207277685112004,
+            7380699292468575143,
+            3332576590029503186,
+            -1107894292705275349,
+            6647229517972286485,
+            6359226207899406831,
+        ],
+    };
+
+    let edges: EdgeFixture = [
+        ((2, 7, Some("b")), edges1_props),
+        ((7, 2, Some("a")), edges2_props),
+    ]
+    .into_iter()
+    .collect();
+
+    let w = -3619743214445905380..90323088878877991;
+    let graph_f = GraphFixture {
+        nodes: NodeFixture::default(),
+        edges,
+    };
+
+    let g = Graph::from(build_graph(&graph_f));
+    let gw = g.window(w.start, w.end);
+    let gmw = gw.materialize()?;
+    assert_graph_equal(&gw, &gmw);
+
+    Ok(())
+}
+
+#[test]
+fn materialize_window_delete_test() {
+    let g = Graph::new();
+    g.delete_edge(0, 0, 0, Some("a")).unwrap();
+    let w = 0..1;
+    let gw = g.window(w.start, w.end);
+    let gmw = gw.materialize().unwrap();
+    assert_graph_equal(&gw, &gmw);
+}
+
 #[test]
 fn test_multilayer() {
     let g = Graph::new();
@@ -3528,8 +3797,8 @@ fn test_empty_window() {
 
 #[test]
 fn add_edge_and_read_props_concurrent() {
-    let g = Graph::new();
     for t in 0..1000 {
+        let g = Graph::new();
         join(
             || g.add_edge(t, 1, 2, [("test", true)], None).unwrap(),
             || {
diff --git a/raphtory/tests/df_loaders.rs b/raphtory/tests/df_loaders.rs
index 229c892916..6f73e97758 100644
--- a/raphtory/tests/df_loaders.rs
+++ b/raphtory/tests/df_loaders.rs
@@ -10,253 +10,20 @@ mod io_tests {
         errors::GraphError,
         io::arrow::{
             dataframe::{DFChunk, DFView},
-            df_loaders::load_edges_from_df,
+            df_loaders::{
+                edges::{load_edges_from_df_prefetch, ColumnNames},
+                nodes::{load_node_props_from_df, load_nodes_from_df},
+            },
         },
         prelude::*,
-        test_utils::{build_edge_list, build_edge_list_str},
+        test_utils::{build_edge_list, build_edge_list_str, build_edge_list_with_secondary_index},
+    };
+    use raphtory_api::core::{entities::LayerIds, storage::arc_str::ArcStr};
+    use raphtory_core::storage::timeindex::EventTime;
+    use raphtory_storage::{
+        core_ops::CoreGraphOps,
+        mutation::addition_ops::{InternalAdditionOps, SessionAdditionOps},
     };
-    use raphtory_storage::core_ops::CoreGraphOps;
-    use tempfile::TempDir;
-
-    #[cfg(feature = "storage")]
-    mod load_multi_layer {
-        use arrow::array::{record_batch, Int64Array, LargeStringArray, RecordBatch, UInt64Array};
-        use parquet::{arrow::ArrowWriter, basic::Compression, file::properties::WriterProperties};
-        use pometry_storage::{
-            chunked_array::array_like::BaseArrayLike, graph::TemporalGraph, load::ExternalEdgeList,
-        };
-        use prop::sample::SizeRange;
-        use proptest::prelude::*;
-        use raphtory::{
-            db::graph::graph::{assert_graph_equal, assert_graph_equal_timestamps},
-            io::parquet_loaders::load_edges_from_parquet,
-            prelude::*,
-            test_utils::build_edge_list,
-        };
-        use raphtory_storage::{disk::DiskGraphStorage, graph::graph::GraphStorage};
-        use std::{
-            fs::File,
-            path::{Path, PathBuf},
-        };
-        use tempfile::TempDir;
-
-        fn build_edge_list_df(
-            len: usize,
-            num_nodes: impl Strategy<Value = u64>,
-            num_layers: impl Into<SizeRange>,
-        ) -> impl Strategy<Value = Vec<RecordBatch>> {
-            let layer = num_nodes
-                .prop_flat_map(move |num_nodes| {
-                    build_edge_list(len, num_nodes)
-                        .prop_filter("no empty edge lists", |el| !el.is_empty())
-                })
-                .prop_map(move |mut rows| {
-                    rows.sort_by_key(|(src, dst, time, _, _)| (*src, *dst, *time));
-                    new_df_from_rows(&rows)
-                });
-            proptest::collection::vec(layer, num_layers)
-        }
-
-        fn new_df_from_rows(rows: &[(u64, u64, i64, String, i64)]) -> RecordBatch {
-            let src = UInt64Array::from_iter_values(rows.iter().map(|(src, ..)| *src));
-            let dst = UInt64Array::from_iter_values(rows.iter().map(|(_, dst, ..)| *dst));
-            let time = Int64Array::from_iter_values(rows.iter().map(|(_, _, time, ..)| *time));
-            let str_prop =
-                LargeStringArray::from_iter_values(rows.iter().map(|(.., str_prop, _)| str_prop));
-            let int_prop =
-                Int64Array::from_iter_values(rows.iter().map(|(.., int_prop)| *int_prop));
-            RecordBatch::try_from_iter([
-                ("src", src.as_array_ref()),
-                ("dst", dst.as_array_ref()),
-                ("time", time.as_array_ref()),
-                ("str_prop", str_prop.as_array_ref()),
-                ("int_prop", int_prop.as_array_ref()),
-            ])
-            .unwrap()
-        }
-
-        fn check_layers_from_df(input: Vec<RecordBatch>, num_threads: usize) {
-            let root_dir = TempDir::new().unwrap();
-            let graph_dir = TempDir::new().unwrap();
-            let layers = input
-                .into_iter()
-                .enumerate()
-                .map(|(i, df)| (i.to_string(), df))
-                .collect::<Vec<_>>();
-            let edge_lists = write_layers(&layers, root_dir.path());
-
-            let expected = Graph::new();
-            for edge_list in &edge_lists {
-                load_edges_from_parquet(
-                    &expected,
-                    &edge_list.path,
-                    "time",
-                    "src",
-                    "dst",
-                    &["int_prop", "str_prop"],
-                    &[],
-                    None,
-                    Some(edge_list.layer),
-                    None,
-                    None,
-                    None,
-                )
-                .unwrap();
-            }
-
-            let g = TemporalGraph::from_parquets(
-                num_threads,
-                13,
-                23,
-                graph_dir.path(),
-                edge_lists,
-                &[],
-                None,
-                None,
-                None,
-                None,
-            )
-            .unwrap();
-            let actual = Graph::from(GraphStorage::Disk(DiskGraphStorage::new(g).into()));
-
-            for layer in expected.unique_layers() {
-                let actual_l = actual.layers(&layer).unwrap();
-                let expected_l = expected.layers(&layer).unwrap();
-                assert_graph_equal(&actual_l, &expected_l);
-            }
-
-            let g = TemporalGraph::new(graph_dir.path()).unwrap();
-
-            for edge in g.edges_iter() {
-                assert!(g.find_edge(edge.src_id(), edge.dst_id()).is_some());
-            }
-
-            let actual = Graph::from(GraphStorage::Disk(DiskGraphStorage::new(g).into()));
-            for layer in expected.unique_layers() {
-                let actual_l = actual.layers(&layer).unwrap();
-                let expected_l = expected.layers(&layer).unwrap();
-                assert_graph_equal(&actual_l, &expected_l);
-            }
-        }
-
-        // DiskGraph appears to have different event ids on time entries
-        fn check_layers_from_df_timestamps(input: Vec<RecordBatch>, num_threads: usize) {
-            let root_dir = TempDir::new().unwrap();
-            let graph_dir = TempDir::new().unwrap();
-            let layers = input
-                .into_iter()
-                .enumerate()
-                .map(|(i, df)| (i.to_string(), df))
-                .collect::<Vec<_>>();
-            let edge_lists = write_layers(&layers, root_dir.path());
-
-            let expected = Graph::new();
-            for edge_list in &edge_lists {
-                load_edges_from_parquet(
-                    &expected,
-                    &edge_list.path,
-                    "time",
-                    "src",
-                    "dst",
-                    &["int_prop", "str_prop"],
-                    &[],
-                    None,
-                    Some(edge_list.layer),
-                    None,
-                    None,
-                    None,
-                )
-                .unwrap();
-            }
-
-            let g = TemporalGraph::from_parquets(
-                num_threads,
-                13,
-                23,
-                graph_dir.path(),
-                edge_lists,
-                &[],
-                None,
-                None,
-                None,
-                None,
-            )
-            .unwrap();
-            let actual = Graph::from(GraphStorage::Disk(DiskGraphStorage::new(g).into()));
-            // FIXME: We have to check each layer individually, checking the whole graph fails because DiskGraph reorders layers when the timestamp is the same (event ids are different)
-            for (layer, _) in layers.iter() {
-                let g_exp = expected.layers(layer).unwrap();
-                let g_actual = actual.layers(layer).unwrap();
-                assert_graph_equal_timestamps(&g_exp, &g_actual);
-            }
-
-            let g = TemporalGraph::new(graph_dir.path()).unwrap();
-
-            for edge in g.edges_iter() {
-                assert!(g.find_edge(edge.src_id(), edge.dst_id()).is_some());
-            }
-
-            let actual = Graph::from(GraphStorage::Disk(DiskGraphStorage::new(g).into()));
-            // FIXME: We have to check each layer individually, checking the whole graph fails because DiskGraph reorders layers when the timestamp is the same (event ids are different)
-            for (layer, _) in layers.iter() {
-                let g_exp = expected.layers(layer).unwrap();
-                let g_actual = actual.layers(layer).unwrap();
-                assert_graph_equal_timestamps(&g_exp, &g_actual);
-            }
-        }
-
-        #[test]
-        fn load_from_multiple_layers() {
-            proptest!(|(input in build_edge_list_df(50, 1u64..23, 1..10,  ), num_threads in 1usize..2)| {
-                check_layers_from_df_timestamps(input, num_threads)
-            });
-        }
-
-        #[test]
-        fn single_layer_single_edge() {
-            let df = new_df_from_rows(&[(0, 0, 1, "".to_owned(), 2)]);
-            check_layers_from_df(vec![df], 1)
-        }
-
-        fn write_layers<'a>(
-            layers: &'a [(String, RecordBatch)],
-            root_dir: &Path,
-        ) -> Vec<ExternalEdgeList<'a, PathBuf>> {
-            let mut paths = vec![];
-            for (name, df) in layers.iter() {
-                let layer_dir = root_dir.join(name);
-                std::fs::create_dir_all(&layer_dir).unwrap();
-                let layer_path = layer_dir.join("edges.parquet");
-
-                paths.push(
-                    ExternalEdgeList::new(
-                        name,
-                        layer_path.to_path_buf(),
-                        "src",
-                        "dst",
-                        "time",
-                        vec![],
-                    )
-                    .unwrap(),
-                );
-
-                let file = File::create(layer_path).unwrap();
-
-                // WriterProperties can be used to set Parquet file options
-                let props = WriterProperties::builder()
-                    .set_compression(Compression::SNAPPY)
-                    .build();
-
-                let mut writer = ArrowWriter::try_new(file, df.schema(), Some(props)).unwrap();
-
-                writer.write(df).expect("Writing batch");
-
-                // writer must be closed to write footer
-                writer.close().unwrap();
-            }
-            paths
-        }
-    }
 
     fn build_df(
         chunk_size: usize,
@@ -344,6 +111,134 @@ mod io_tests {
         }
     }
 
+    fn build_df_with_secondary_index(
+        chunk_size: usize,
+        edges: &[(u64, u64, i64, u64, String, i64)],
+    ) -> DFView<impl Iterator<Item = Result<DFChunk, GraphError>>> {
+        let chunks = edges.iter().chunks(chunk_size);
+        let mut src_col = UInt64Builder::new();
+        let mut dst_col = UInt64Builder::new();
+        let mut time_col = Int64Builder::new();
+        let mut secondary_index_col = UInt64Builder::new();
+        let mut str_prop_col = LargeStringBuilder::new();
+        let mut int_prop_col = Int64Builder::new();
+        let chunks = chunks
+            .into_iter()
+            .map(|chunk| {
+                for (src, dst, time, secondary_index, str_prop, int_prop) in chunk {
+                    src_col.append_value(*src);
+                    dst_col.append_value(*dst);
+                    time_col.append_value(*time);
+                    secondary_index_col.append_value(*secondary_index);
+                    str_prop_col.append_value(str_prop);
+                    int_prop_col.append_value(*int_prop);
+                }
+
+                let chunk = vec![
+                    ArrayBuilder::finish(&mut src_col),
+                    ArrayBuilder::finish(&mut dst_col),
+                    ArrayBuilder::finish(&mut time_col),
+                    ArrayBuilder::finish(&mut secondary_index_col),
+                    ArrayBuilder::finish(&mut str_prop_col),
+                    ArrayBuilder::finish(&mut int_prop_col),
+                ];
+
+                Ok(DFChunk { chunk })
+            })
+            .collect_vec();
+
+        DFView {
+            names: vec![
+                "src".to_owned(),
+                "dst".to_owned(),
+                "time".to_owned(),
+                "secondary_index".to_owned(),
+                "str_prop".to_owned(),
+                "int_prop".to_owned(),
+            ],
+            chunks: chunks.into_iter(),
+            num_rows: Some(edges.len()),
+        }
+    }
+
+    fn build_nodes_df(
+        chunk_size: usize,
+        nodes: &[(u64, i64, &str)],
+    ) -> DFView<impl Iterator<Item = Result<DFChunk, GraphError>>> {
+        let chunks = nodes.iter().chunks(chunk_size);
+        let mut node_id_col = UInt64Builder::new();
+        let mut time_col = Int64Builder::new();
+        let mut node_type_col = StringViewBuilder::new();
+        let chunks = chunks
+            .into_iter()
+            .map(|chunk| {
+                for (node_id, time, node_type) in chunk {
+                    node_id_col.append_value(*node_id);
+                    time_col.append_value(*time);
+                    node_type_col.append_value(node_type);
+                }
+                let chunk = vec![
+                    ArrayBuilder::finish(&mut node_id_col),
+                    ArrayBuilder::finish(&mut time_col),
+                    ArrayBuilder::finish(&mut node_type_col),
+                ];
+                Ok(DFChunk { chunk })
+            })
+            .collect_vec();
+        DFView {
+            names: vec!["id".to_owned(), "time".to_owned(), "node_type".to_owned()],
+            chunks: chunks.into_iter(),
+            num_rows: Some(nodes.len()),
+        }
+    }
+
+    fn build_nodes_df_with_secondary_index(
+        chunk_size: usize,
+        nodes: &[(u64, i64, u64, &str, i64, &str)],
+    ) -> DFView<impl Iterator<Item = Result<DFChunk, GraphError>>> {
+        let chunks = nodes.iter().chunks(chunk_size);
+        let mut node_id_col = UInt64Builder::new();
+        let mut time_col = Int64Builder::new();
+        let mut secondary_index_col = UInt64Builder::new();
+        let mut str_prop_col = LargeStringBuilder::new();
+        let mut int_prop_col = Int64Builder::new();
+        let mut node_type_col = StringViewBuilder::new();
+        let chunks = chunks
+            .into_iter()
+            .map(|chunk| {
+                for (node_id, time, secondary_index, str_prop, int_prop, node_type) in chunk {
+                    node_id_col.append_value(*node_id);
+                    time_col.append_value(*time);
+                    secondary_index_col.append_value(*secondary_index);
+                    str_prop_col.append_value(str_prop);
+                    int_prop_col.append_value(*int_prop);
+                    node_type_col.append_value(node_type);
+                }
+                let chunk = vec![
+                    ArrayBuilder::finish(&mut node_id_col),
+                    ArrayBuilder::finish(&mut time_col),
+                    ArrayBuilder::finish(&mut secondary_index_col),
+                    ArrayBuilder::finish(&mut str_prop_col),
+                    ArrayBuilder::finish(&mut int_prop_col),
+                    ArrayBuilder::finish(&mut node_type_col),
+                ];
+                Ok(DFChunk { chunk })
+            })
+            .collect_vec();
+        DFView {
+            names: vec![
+                "node_id".to_owned(),
+                "time".to_owned(),
+                "secondary_index".to_owned(),
+                "str_prop".to_owned(),
+                "int_prop".to_owned(),
+                "node_type".to_owned(),
+            ],
+            chunks: chunks.into_iter(),
+            num_rows: Some(nodes.len()),
+        }
+    }
+
     #[test]
     fn test_load_edges() {
         proptest!(|(edges in build_edge_list(1000, 100), chunk_size in 1usize..=1000)| {
@@ -351,17 +246,185 @@ mod io_tests {
             let df_view = build_df(chunk_size, &edges);
             let g = Graph::new();
             let props = ["str_prop", "int_prop"];
-            load_edges_from_df(df_view, "time", "src", "dst", &props, &[], None, None, None, &g).unwrap();
+            let secondary_index = None;
+            load_edges_from_df_prefetch(df_view,
+                ColumnNames::new("time", secondary_index, "src", "dst", None),
+                true,
+                &props, &[], None, None, &g, false).unwrap();
+
             let g2 = Graph::new();
+
             for (src, dst, time, str_prop, int_prop) in edges {
                 g2.add_edge(time, src, dst, [("str_prop", str_prop.clone().into_prop()), ("int_prop", int_prop.into_prop())], None).unwrap();
+                let edge = g2.edge(src, dst).unwrap().at(time);
+                assert_eq!(edge.properties().get("str_prop").unwrap_str(), str_prop);
+                assert_eq!(edge.properties().get("int_prop").unwrap_i64(), int_prop);
             }
-            assert_eq!(g.unfiltered_num_edges(), distinct_edges);
-            assert_eq!(g2.unfiltered_num_edges(), distinct_edges);
+
+            let count_edges = g.core_edges().iter(&LayerIds::All).count();
+            assert_eq!(g.unfiltered_num_edges(&LayerIds::All), distinct_edges);
+            assert_eq!(g2.unfiltered_num_edges(&LayerIds::All), distinct_edges);
+            assert_eq!(count_edges, distinct_edges);
             assert_graph_equal(&g, &g2);
         })
     }
 
+    // def test_load_from_pandas():
+    #[test]
+    fn load_some_edges_as_in_python() {
+        use arrow::array::builder::{Float64Builder, LargeStringBuilder};
+
+        // Create the dataframe equivalent to the pandas DataFrame
+        let edges = vec![
+            (1u64, 2u64, 1i64, 1.0f64, "red".to_string()),
+            (2, 3, 2, 2.0, "blue".to_string()),
+            (3, 4, 3, 3.0, "green".to_string()),
+            (4, 5, 4, 4.0, "yellow".to_string()),
+            (5, 6, 5, 5.0, "purple".to_string()),
+        ];
+
+        // Build the dataframe
+        let mut src_col = UInt64Builder::new();
+        let mut dst_col = UInt64Builder::new();
+        let mut time_col = Int64Builder::new();
+        let mut weight_col = Float64Builder::new();
+        let mut marbles_col = LargeStringBuilder::new();
+
+        for (src, dst, time, weight, marbles) in &edges {
+            src_col.append_value(*src);
+            dst_col.append_value(*dst);
+            time_col.append_value(*time);
+            weight_col.append_value(*weight);
+            marbles_col.append_value(marbles);
+        }
+
+        let chunk = vec![
+            ArrayBuilder::finish(&mut src_col),
+            ArrayBuilder::finish(&mut dst_col),
+            ArrayBuilder::finish(&mut time_col),
+            ArrayBuilder::finish(&mut weight_col),
+            ArrayBuilder::finish(&mut marbles_col),
+        ];
+
+        let df_view = DFView {
+            names: vec![
+                "src".to_owned(),
+                "dst".to_owned(),
+                "time".to_owned(),
+                "weight".to_owned(),
+                "marbles".to_owned(),
+            ],
+            chunks: vec![Ok(DFChunk { chunk })].into_iter(),
+            num_rows: Some(edges.len()),
+        };
+
+        // Load edges into graph
+        let g = Graph::new();
+        let props = ["weight", "marbles"];
+        load_edges_from_df_prefetch(
+            df_view,
+            ColumnNames::new("time", None, "src", "dst", None),
+            true,
+            &props,
+            &[],
+            None,
+            None,
+            &g,
+            false,
+        )
+        .unwrap();
+
+        // Expected values
+        let expected_nodes = vec![1u64, 2, 3, 4, 5, 6];
+        let mut expected_edges = vec![
+            (1u64, 2u64, 1.0f64, "red".to_string()),
+            (2, 3, 2.0, "blue".to_string()),
+            (3, 4, 3.0, "green".to_string()),
+            (4, 5, 4.0, "yellow".to_string()),
+            (5, 6, 5.0, "purple".to_string()),
+        ];
+
+        // Collect actual nodes
+        let mut actual_nodes: Vec<u64> = g
+            .nodes()
+            .id()
+            .into_iter()
+            .flat_map(|(_, id)| id.as_u64())
+            .collect();
+        actual_nodes.sort();
+
+        // Collect actual edges
+        let mut actual_edges: Vec<(u64, u64, f64, String)> = g
+            .edges()
+            .iter()
+            .filter_map(|e| {
+                let weight = e.properties().get("weight").unwrap_f64();
+                let marbles = e.properties().get("marbles").unwrap_str().to_string();
+                Some((
+                    e.src().id().as_u64()?,
+                    e.dst().id().as_u64()?,
+                    weight,
+                    marbles,
+                ))
+            })
+            .collect();
+        actual_edges.sort_by(|a, b| a.0.cmp(&b.0).then(a.1.cmp(&b.1)));
+        expected_edges.sort_by(|a, b| a.0.cmp(&b.0).then(a.1.cmp(&b.1)));
+
+        // Assertions
+        assert_eq!(actual_nodes, expected_nodes);
+        assert_eq!(actual_edges, expected_edges);
+    }
+
+    #[test]
+    fn test_simultaneous_edge_update() {
+        let edges = [(0, 1, 0, "".to_string(), 0), (0, 1, 0, "".to_string(), 1)];
+
+        let distinct_edges = edges
+            .iter()
+            .map(|(src, dst, _, _, _)| (src, dst))
+            .collect::<std::collections::HashSet<_>>()
+            .len();
+        let df_view = build_df(1, &edges);
+        let g = Graph::new();
+        let props = ["str_prop", "int_prop"];
+        let secondary_index = None;
+
+        load_edges_from_df_prefetch(
+            df_view,
+            ColumnNames::new("time", secondary_index, "src", "dst", None),
+            true,
+            &props,
+            &[],
+            None,
+            None,
+            &g,
+            false,
+        )
+        .unwrap();
+
+        let g2 = Graph::new();
+        for (src, dst, time, str_prop, int_prop) in edges {
+            g2.add_edge(
+                time,
+                src,
+                dst,
+                [
+                    ("str_prop", str_prop.clone().into_prop()),
+                    ("int_prop", int_prop.into_prop()),
+                ],
+                None,
+            )
+            .unwrap();
+            let edge = g2.edge(src, dst).unwrap().at(time);
+            assert_eq!(edge.properties().get("str_prop").unwrap_str(), str_prop);
+            assert_eq!(edge.properties().get("int_prop").unwrap_i64(), int_prop);
+        }
+        assert_eq!(g.unfiltered_num_edges(&LayerIds::All), distinct_edges);
+        assert_eq!(g2.unfiltered_num_edges(&LayerIds::All), distinct_edges);
+        assert_graph_equal(&g, &g2);
+    }
+
     #[test]
     fn test_load_edges_str() {
         proptest!(|(edges in build_edge_list_str(100, 100), chunk_size in 1usize..=100)| {
@@ -369,13 +432,16 @@ mod io_tests {
             let df_view = build_df_str(chunk_size, &edges);
             let g = Graph::new();
             let props = ["str_prop", "int_prop"];
-            load_edges_from_df(df_view, "time", "src", "dst", &props, &[], None, None, None, &g).unwrap();
+            load_edges_from_df_prefetch(df_view, ColumnNames::new("time", None, "src", "dst", None), true, &props, &[], None, None, &g, false).unwrap();
+
             let g2 = Graph::new();
+
             for (src, dst, time, str_prop, int_prop) in edges {
                 g2.add_edge(time, &src, &dst, [("str_prop", str_prop.clone().into_prop()), ("int_prop", int_prop.into_prop())], None).unwrap();
             }
-            assert_eq!(g.unfiltered_num_edges(), distinct_edges);
-            assert_eq!(g2.unfiltered_num_edges(), distinct_edges);
+
+            assert_eq!(g.unfiltered_num_edges(&LayerIds::All), distinct_edges);
+            assert_eq!(g2.unfiltered_num_edges(&LayerIds::All), distinct_edges);
             assert_graph_equal(&g, &g2);
         })
     }
@@ -386,77 +452,326 @@ mod io_tests {
         let df_view = build_df_str(1, &edges);
         let g = Graph::new();
         let props = ["str_prop", "int_prop"];
-        load_edges_from_df(
+        load_edges_from_df_prefetch(
             df_view,
-            "time",
-            "src",
-            "dst",
+            ColumnNames::new("time", None, "src", "dst", None),
+            true,
             &props,
             &[],
             None,
             None,
-            None,
             &g,
+            false,
         )
         .unwrap();
+
         assert!(g.has_edge("0", "1"))
     }
 
     #[test]
-    fn test_load_edges_with_cache() {
-        proptest!(|(edges in build_edge_list(100, 100), chunk_size in 1usize..=100)| {
-            let df_view = build_df(chunk_size, &edges);
+    fn test_load_edges_with_secondary_index() {
+        // Create edges with the same timestamp but different secondary_index values
+        // Edge format: (src, dst, time, secondary_index, str_prop, int_prop)
+        let edges = [
+            (1, 2, 100, 2, "secondary_index_2".to_string(), 1),
+            (1, 2, 100, 0, "secondary_index_0".to_string(), 2),
+            (1, 2, 100, 1, "secondary_index_1".to_string(), 3),
+            (2, 3, 200, 1, "secondary_index_1".to_string(), 4),
+            (2, 3, 200, 0, "secondary_index_0".to_string(), 5),
+            (3, 4, 300, 10, "secondary_index_10".to_string(), 6),
+            (3, 4, 300, 5, "secondary_index_5".to_string(), 7),
+            (4, 5, 400, 0, "secondary_index_0".to_string(), 8),
+            (4, 5, 500, 0, "secondary_index_0".to_string(), 9),
+        ];
+
+        let chunk_size = 50;
+        let df_view = build_df_with_secondary_index(chunk_size, &edges);
+        let g = Graph::new();
+        let props = ["str_prop", "int_prop"];
+        let secondary_index = Some("secondary_index");
+
+        // Load edges from DataFrame with secondary_index
+        load_edges_from_df_prefetch(
+            df_view,
+            ColumnNames::new("time", secondary_index, "src", "dst", None),
+            true,
+            &props,
+            &[],
+            None,
+            None,
+            &g,
+            false,
+        )
+        .unwrap();
+
+        let g2 = Graph::new();
+
+        for (src, dst, time, secondary_index, str_prop, int_prop) in edges {
+            let time_with_secondary_index = EventTime::new(time, secondary_index as usize);
+
+            g2.add_edge(
+                time_with_secondary_index,
+                src,
+                dst,
+                [
+                    ("str_prop", str_prop.clone().into_prop()),
+                    ("int_prop", int_prop.into_prop()),
+                ],
+                None,
+            )
+            .unwrap();
+        }
+
+        // Internally checks whether temporal props are sorted by
+        // secondary index.
+        assert_graph_equal(&g, &g2);
+
+        // Both graphs should have the same event_id / secondary_index
+        assert_eq!(
+            g.write_session().unwrap().read_event_id().unwrap(),
+            g2.write_session().unwrap().read_event_id().unwrap(),
+        );
+
+        assert_eq!(
+            g.write_session().unwrap().read_event_id().unwrap(),
+            10 // max secondary index in edges
+        );
+    }
+
+    #[test]
+    fn test_load_edges_with_secondary_index_proptest() {
+        let len = 1000;
+        let num_nodes = 100;
+
+        proptest!(|(edges in build_edge_list_with_secondary_index(len, num_nodes), chunk_size in 1usize..=len)| {
+            let distinct_edges = edges.iter().map(|(src, dst, _, _, _, _)| (src, dst)).collect::<std::collections::HashSet<_>>().len();
+            let df_view = build_df_with_secondary_index(chunk_size, &edges);
             let g = Graph::new();
-            let cache_file = TempDir::new().unwrap();
-            g.cache(cache_file.path()).unwrap();
             let props = ["str_prop", "int_prop"];
-            load_edges_from_df(df_view, "time", "src", "dst", &props, &[], None, None, None, &g).unwrap();
-            let g = Graph::load_cached(cache_file.path()).unwrap();
+            let secondary_index = Some("secondary_index");
+
+            load_edges_from_df_prefetch(
+                df_view,
+                ColumnNames::new("time", secondary_index, "src", "dst", None),
+                true,
+                &props,
+                &[],
+                None,
+                None,
+                &g,
+                false,
+            ).unwrap();
+
             let g2 = Graph::new();
-            for (src, dst, time, str_prop, int_prop) in edges {
-                g2.add_edge(time, src, dst, [("str_prop", str_prop.clone().into_prop()), ("int_prop", int_prop.into_prop())], None).unwrap();
+            let mut max_secondary_index = 0;
+
+            for (src, dst, time, secondary_index_val, str_prop, int_prop) in edges {
+                let time_with_secondary_index = EventTime(time, secondary_index_val as usize);
+
+                g2.add_edge(
+                    time_with_secondary_index,
+                    src,
+                    dst,
+                    [
+                        ("str_prop", str_prop.clone().into_prop()),
+                        ("int_prop", int_prop.into_prop()),
+                    ],
+                    None,
+                ).unwrap();
+
+                let edge = g.edge(src, dst).unwrap().at(time);
+                assert_eq!(edge.properties().get("str_prop").unwrap_str(), str_prop);
+                assert_eq!(edge.properties().get("int_prop").unwrap_i64(), int_prop);
+
+                // Track the maximum secondary_index value to compare later
+                max_secondary_index = max_secondary_index.max(secondary_index_val as usize);
             }
+
+            assert_eq!(g.unfiltered_num_edges(&LayerIds::All), distinct_edges);
+            assert_eq!(g2.unfiltered_num_edges(&LayerIds::All), distinct_edges);
             assert_graph_equal(&g, &g2);
+
+            // Both graphs should have the same event_id / secondary_index
+            assert_eq!(
+                g.write_session().unwrap().read_event_id().unwrap(),
+                g2.write_session().unwrap().read_event_id().unwrap(),
+            );
+
+            assert_eq!(
+                g.write_session().unwrap().read_event_id().unwrap(),
+                max_secondary_index
+            );
         })
     }
 
     #[test]
-    fn load_single_edge_with_cache() {
-        let edges = [(0, 0, 0, "".to_string(), 0)];
-        let df_view = build_df(1, &edges);
+    fn test_load_nodes_with_secondary_index() {
+        // Create nodes with the same timestamp but different secondary_index values
+        // Node format: (node_id, time, secondary_index, str_prop, int_prop)
+        let nodes = [
+            (1, 100, 2, "secondary_index_2", 1, "TypeA"),
+            (1, 100, 0, "secondary_index_0", 2, "TypeA"),
+            (1, 100, 1, "secondary_index_1", 3, "TypeA"),
+            (2, 200, 1, "secondary_index_1", 4, "TypeA"),
+            (2, 200, 0, "secondary_index_0", 5, "TypeA"),
+            (3, 300, 10, "secondary_index_10", 6, "TypeC"),
+            (3, 300, 5, "secondary_index_5", 7, "TypeC"),
+            (4, 400, 0, "secondary_index_0", 8, "TypeA"),
+            (4, 500, 0, "secondary_index_0", 9, "TypeA"),
+        ];
+
+        let nodes_no_dupes = [
+            (1, 100, 2, "secondary_index_2", 1, "TypeA"),
+            (2, 200, 1, "secondary_index_1", 4, "TypeA"),
+            (4, 400, 0, "secondary_index_0", 8, "TypeA"),
+            (3, 300, 5, "secondary_index_5", 7, "TypeC"),
+        ];
+
+        let chunk_size = 50;
+        let df_view = build_nodes_df_with_secondary_index(chunk_size, &nodes);
         let g = Graph::new();
-        let cache_file = TempDir::new().unwrap();
-        g.cache(cache_file.path()).unwrap();
         let props = ["str_prop", "int_prop"];
-        load_edges_from_df(
+        let secondary_index = Some("secondary_index");
+
+        // Load nodes from DataFrame with secondary_index
+        load_nodes_from_df(
             df_view,
             "time",
-            "src",
-            "dst",
+            secondary_index,
+            "node_id",
             &props,
             &[],
             None,
             None,
             None,
             &g,
+            true,
+            None,
+            None,
         )
         .unwrap();
-        let g = Graph::load_cached(cache_file.path()).unwrap();
+
+        let df_view = build_nodes_df_with_secondary_index(chunk_size, &nodes_no_dupes);
+
+        load_node_props_from_df(
+            df_view,
+            "node_id",
+            None,
+            Some("node_type"),
+            None,
+            None,
+            &[],
+            None,
+            &g,
+        )
+        .unwrap();
+
         let g2 = Graph::new();
-        for (src, dst, time, str_prop, int_prop) in edges {
-            g2.add_edge(
-                time,
-                src,
-                dst,
+
+        for (node_id, time, secondary_index, str_prop, int_prop, node_type) in nodes {
+            let time_with_secondary_index = EventTime(time, secondary_index as usize);
+
+            g2.add_node(
+                time_with_secondary_index,
+                node_id,
                 [
-                    ("str_prop", str_prop.clone().into_prop()),
+                    ("str_prop", str_prop.into_prop()),
                     ("int_prop", int_prop.into_prop()),
                 ],
+                Some(node_type),
                 None,
             )
             .unwrap();
         }
+
+        // Internally checks whether temporal props are sorted by
+        // secondary index.
         assert_graph_equal(&g, &g2);
+
+        // Both graphs should have the same event_id / secondary_index
+        assert_eq!(
+            g.write_session().unwrap().read_event_id().unwrap(),
+            g2.write_session().unwrap().read_event_id().unwrap(),
+        );
+
+        assert_eq!(
+            g.write_session().unwrap().read_event_id().unwrap(),
+            10 // max secondary index in nodes
+        );
+
+        let mut act_node_types = g
+            .nodes()
+            .node_type()
+            .compute()
+            .into_iter()
+            .filter_map(|(node, val)| Some((node.id().as_u64()?, val)))
+            .collect_vec();
+        act_node_types.sort();
+        let exp_node_types = vec![
+            (1u64, Some(ArcStr::from("TypeA"))),
+            (2u64, Some(ArcStr::from("TypeA"))),
+            (3u64, Some(ArcStr::from("TypeC"))),
+            (4u64, Some(ArcStr::from("TypeA"))),
+        ];
+        assert_eq!(act_node_types, exp_node_types);
+
+        let mut act_node_types = g.nodes().node_type().iter_values().collect_vec();
+        act_node_types.sort();
+        let exp_node_types = vec![
+            Some(ArcStr::from("TypeA")),
+            Some(ArcStr::from("TypeA")),
+            Some(ArcStr::from("TypeA")),
+            Some(ArcStr::from("TypeC")),
+        ];
+        assert_eq!(act_node_types, exp_node_types);
+    }
+
+    #[test]
+    fn test_load_node_type_only() {
+        // (node_id, time, node_type)
+        let nodes: Vec<(u64, i64, &str)> = vec![
+            (1, 1, "P1"),
+            (2, 2, "P2"),
+            (3, 3, "P3"),
+            (4, 4, "P4"),
+            (5, 5, "P5"),
+            (6, 6, "P6"),
+        ];
+
+        // CHECK ALL NODE FUNCTIONS ON GRAPH FAIL WITH BOTH node_type AND node_type_col
+        let g = Graph::new();
+        load_nodes_from_df(
+            build_nodes_df(50, &nodes),
+            "time",
+            None,
+            "id",
+            &[],
+            &[],
+            None,
+            None,              // node_type (constant name)
+            Some("node_type"), // node_type_col (column name) — conflict!
+            &g,
+            true,
+            None,
+            None,
+        )
+        .unwrap();
+        let mut result = g
+            .nodes()
+            .into_iter()
+            .map(|node| (node.id(), node.node_type()))
+            .collect::<Vec<_>>();
+
+        result.sort();
+        let expected: Vec<(GID, Option<ArcStr>)> = vec![
+            (1u64.into(), Some(ArcStr::from("P1"))),
+            (2u64.into(), Some(ArcStr::from("P2"))),
+            (3u64.into(), Some(ArcStr::from("P3"))),
+            (4u64.into(), Some(ArcStr::from("P4"))),
+            (5u64.into(), Some(ArcStr::from("P5"))),
+            (6u64.into(), Some(ArcStr::from("P6"))),
+        ];
+        assert_eq!(result, expected);
     }
 }
 
@@ -473,12 +788,15 @@ mod parquet_tests {
         },
         prelude::*,
         test_utils::{
-            build_edge_list_dyn, build_graph, build_graph_strat, build_nodes_dyn, build_props_dyn,
-            EdgeFixture, EdgeUpdatesFixture, GraphFixture, NodeFixture, NodeUpdatesFixture,
-            PropUpdatesFixture,
+            assert_valid_graph, build_edge_list_dyn, build_graph, build_graph_strat,
+            build_nodes_dyn, build_props_dyn, EdgeFixture, EdgeUpdatesFixture, GraphFixture,
+            NodeFixture, NodeUpdatesFixture, PropUpdatesFixture,
         },
     };
-    use std::str::FromStr;
+    use serde_json::json;
+    use std::{io::Cursor, str::FromStr};
+    use storage::Config;
+    use zip::{ZipArchive, ZipWriter};
 
     #[test]
     fn node_temp_props() {
@@ -708,14 +1026,14 @@ mod parquet_tests {
                     1,
                     12,
                     vec![("a".to_string(), Prop::List(vec![].into()))],
-                    None,
+                    None::<String>,
                 ),
                 (
                     1,
                     2,
                     12,
                     vec![("a".to_string(), Prop::List(vec![Prop::str("aa")].into()))],
-                    None,
+                    None::<String>,
                 ),
             ]
             .into(),
@@ -733,7 +1051,7 @@ mod parquet_tests {
                 0,
                 0,
                 vec![("a".to_string(), Prop::List(vec![Prop::DTime(dt)].into()))],
-                None,
+                None::<String>,
             )]
             .into(),
         );
@@ -752,7 +1070,7 @@ mod parquet_tests {
                     "a".to_string(),
                     Prop::map([("a", Prop::DTime(dt)), ("b", Prop::str("s"))]),
                 )],
-                None,
+                None::<String>,
             )]
             .into(),
         );
@@ -767,14 +1085,14 @@ mod parquet_tests {
                     0,
                     0,
                     vec![("a".to_string(), Prop::map([("a", Prop::I32(1))]))],
-                    None,
+                    None::<String>,
                 ),
                 (
                     0,
                     0,
                     0,
                     vec![("a".to_string(), Prop::map([("b", Prop::str("x"))]))],
-                    None,
+                    None::<String>,
                 ),
             ]
             .into(),
@@ -785,13 +1103,19 @@ mod parquet_tests {
     fn edges_maps3() {
         build_and_check_parquet_encoding(
             [
-                (0, 0, 0, vec![("a".to_string(), Prop::U8(5))], None),
+                (
+                    0,
+                    0,
+                    0,
+                    vec![("a".to_string(), Prop::U8(5))],
+                    None::<String>,
+                ),
                 (
                     0,
                     0,
                     0,
                     vec![("b".to_string(), Prop::map([("c", Prop::U8(66))]))],
-                    None,
+                    None::<String>,
                 ),
             ]
             .into(),
@@ -829,20 +1153,24 @@ mod parquet_tests {
     // proptest
     fn build_and_check_parquet_encoding(edges: GraphFixture) {
         let g = Graph::from(build_graph(&edges));
-        check_parquet_encoding(g);
+        check_parquet_encoding(&g, Some(edges));
     }
 
-    fn check_parquet_encoding(g: Graph) {
+    fn check_parquet_encoding(g: &Graph, fixture: Option<GraphFixture>) {
         let temp_dir = tempfile::tempdir().unwrap();
         g.encode_parquet(&temp_dir).unwrap();
-        let g2 = Graph::decode_parquet(&temp_dir).unwrap();
+        let g2 = Graph::decode_parquet(&temp_dir, None, Config::default()).unwrap();
+        if let Some(f) = fixture {
+            assert_valid_graph(&f, g);
+            assert_valid_graph(&f, &g2);
+        }
         assert_graph_equal_timestamps(&g, &g2);
     }
 
     fn check_parquet_encoding_deletions(g: PersistentGraph) {
         let temp_dir = tempfile::tempdir().unwrap();
         g.encode_parquet(&temp_dir).unwrap();
-        let g2 = PersistentGraph::decode_parquet(&temp_dir).unwrap();
+        let g2 = PersistentGraph::decode_parquet(&temp_dir, None, Config::default()).unwrap();
         assert_graph_equal_timestamps(&g, &g2);
     }
 
@@ -856,13 +1184,10 @@ mod parquet_tests {
                 0,
                 NodeUpdatesFixture {
                     props: PropUpdatesFixture {
-                        t_props: vec![(
-                            0,
-                            vec![
-                                ("a".to_string(), Prop::U8(5)),
-                                ("a".to_string(), Prop::U8(5)),
-                            ],
-                        )],
+                        t_props: vec![
+                            (0, vec![("a".to_string(), Prop::U8(5))]),
+                            (0, vec![("a".to_string(), Prop::U8(5))]),
+                        ],
                         c_props: vec![("b".to_string(), Prop::DTime(dt))],
                     },
                     node_type: None,
@@ -883,7 +1208,7 @@ mod parquet_tests {
 
         g.add_metadata(nf.c_props).unwrap();
         g.encode_parquet(&temp_dir).unwrap();
-        let g2 = Graph::decode_parquet(&temp_dir).unwrap();
+        let g2 = Graph::decode_parquet(&temp_dir, None, Config::default()).unwrap();
         if only_timestamps {
             assert_graph_equal_timestamps(&g, &g2)
         } else {
@@ -920,7 +1245,7 @@ mod parquet_tests {
 
     #[test]
     fn write_graph_props_to_parquet() {
-        proptest!(|(props in build_props_dyn(10))| {
+        proptest!(|(props in build_props_dyn(0..=10))| {
             check_graph_props(props, true);
         });
     }
@@ -936,21 +1261,39 @@ mod parquet_tests {
 
     #[test]
     fn write_nodes_any_props_to_parquet() {
-        proptest!(|(nodes in build_nodes_dyn(10, 10))| {
+        proptest!(|(nodes in build_nodes_dyn(0..=10, 0..=10, 0..=10))| {
             build_and_check_parquet_encoding(nodes.into());
         });
     }
     #[test]
     fn write_edges_any_props_to_parquet() {
-        proptest!(|(edges in build_edge_list_dyn(10, 10, true))| {
+        proptest!(|(edges in build_edge_list_dyn(0..=10, 0..=10, 0..=10, 0..=10, true))| {
             build_and_check_parquet_encoding(edges.into());
         });
     }
 
+    #[test]
+    fn write_edges_any_props_failure() {
+        let edges: EdgeFixture = serde_json::from_value(json!([[[5,9,"b"],{"props":{"t_props":[[0,[]]],"c_props":[]},"deletions":[]}],[[5,9,"a"],{"props":{"t_props":[[0,[]]],"c_props":[]},"deletions":[]}]])).unwrap();
+        let temp_dir = tempfile::tempdir().unwrap();
+        let graph_f = edges.into();
+        let g = Graph::from(build_graph(&graph_f));
+        dbg!(&g);
+        g.encode_parquet(&temp_dir).unwrap();
+        let g2 = Graph::decode_parquet(&temp_dir, None, Config::default()).unwrap();
+        dbg!(&g2);
+        assert_eq!(g2.valid_layers("b").count_edges(), 1);
+        assert_eq!(g2.valid_layers("a").count_edges(), 1);
+
+        assert_eq!(g.valid_layers("b").count_edges(), 1);
+
+        assert_graph_equal_timestamps(&g, &g2);
+    }
+
     #[test]
     fn write_graph_to_parquet() {
-        proptest!(|(edges in build_graph_strat(10, 10, true))| {
-            build_and_check_parquet_encoding(edges);
+        proptest!(|(graph in build_graph_strat(10, 10, 10, 10, true))| {
+            build_and_check_parquet_encoding(graph);
         })
     }
 
@@ -967,6 +1310,92 @@ mod parquet_tests {
         graph
             .add_edge(0, 0, 1, [("test", Prop::map(NO_PROPS))], None)
             .unwrap();
-        check_parquet_encoding(graph);
+        check_parquet_encoding(&graph, None);
+    }
+
+    #[test]
+    fn test_parquet_zip_simple() {
+        let g = Graph::new();
+
+        g.add_edge(0, 0, 1, [("test prop 1", Prop::map(NO_PROPS))], None)
+            .unwrap();
+        g.add_edge(
+            1,
+            2,
+            3,
+            [("test prop 1", Prop::map([("key", "value")]))],
+            Some("layer_a"),
+        )
+        .unwrap();
+        g.add_edge(2, 3, 4, [("test prop 2", "value")], Some("layer_b"))
+            .unwrap();
+        g.add_edge(3, 1, 4, [("test prop 3", 10.0)], None).unwrap();
+        g.add_edge(4, 1, 3, [("test prop 4", true)], None).unwrap();
+
+        let temp_dir = tempfile::tempdir().unwrap();
+        let zip_path = temp_dir.path().join("test_graph.zip");
+
+        // Test writing to a file
+        let file = std::fs::File::create(&zip_path).unwrap();
+        let mut writer = ZipWriter::new(file);
+        g.encode_parquet_to_zip(&mut writer, "graph").unwrap();
+        writer.finish().unwrap();
+
+        let mut reader = ZipArchive::new(std::fs::File::open(&zip_path).unwrap()).unwrap();
+        let g2 = Graph::decode_parquet_from_zip(
+            &mut reader,
+            None::<&std::path::Path>,
+            "graph",
+            Config::default(),
+        )
+        .unwrap();
+        assert_graph_equal(&g, &g2);
+    }
+
+    #[test]
+    fn test_parquet_bytes_simple() {
+        let g = Graph::new();
+
+        g.add_edge(0, 0, 1, [("test prop 1", Prop::map(NO_PROPS))], None)
+            .unwrap();
+        g.add_edge(
+            1,
+            2,
+            3,
+            [("test prop 1", Prop::map([("key", "value")]))],
+            Some("layer_a"),
+        )
+        .unwrap();
+        g.add_edge(2, 3, 4, [("test prop 2", "value")], Some("layer_b"))
+            .unwrap();
+        g.add_edge(3, 1, 4, [("test prop 3", 10.0)], None).unwrap();
+        g.add_edge(4, 1, 3, [("test prop 4", true)], None).unwrap();
+
+        let mut bytes = Vec::new();
+        let mut writer = ZipWriter::new(Cursor::new(&mut bytes));
+        g.encode_parquet_to_zip(&mut writer, "graph").unwrap();
+        writer.finish().unwrap();
+        let g2 = Graph::decode_parquet_from_bytes(
+            &bytes,
+            None::<&std::path::Path>,
+            "graph",
+            Config::default(),
+        )
+        .unwrap();
+        assert_graph_equal(&g, &g2);
+    }
+
+    #[test]
+    fn test_parquet_bytes_proptest() {
+        proptest!(|(edges in build_graph_strat(30, 30, 10, 10, true))| {
+            let g = Graph::from(build_graph(&edges));
+            let mut bytes = Vec::new();
+            let mut writer = ZipWriter::new(Cursor::new(&mut bytes));
+            g.encode_parquet_to_zip(&mut writer, "graph").unwrap();
+            writer.finish().unwrap();
+            let g2 = Graph::decode_parquet_from_bytes(&bytes, None::<&std::path::Path>, "graph", Config::default()).unwrap();
+
+            assert_graph_equal(&g, &g2);
+        })
     }
 }
diff --git a/raphtory/tests/disk_storage.rs b/raphtory/tests/disk_storage.rs
deleted file mode 100644
index 2bfcb6c871..0000000000
--- a/raphtory/tests/disk_storage.rs
+++ /dev/null
@@ -1,1069 +0,0 @@
-#[cfg(feature = "storage")]
-#[cfg(test)]
-mod test {
-    use arrow::array::StringArray;
-    use bigdecimal::BigDecimal;
-    use itertools::Itertools;
-    use pometry_storage::{
-        chunked_array::array_like::BaseArrayLike, graph::TemporalGraph, properties::Properties,
-    };
-    use proptest::{prelude::*, sample::size_range};
-    use raphtory::{
-        db::{
-            api::view::StaticGraphViewOps,
-            graph::graph::{assert_graph_equal, assert_graph_equal_timestamps},
-        },
-        prelude::*,
-    };
-    use raphtory_api::core::{entities::properties::prop::Prop, storage::timeindex::AsTime};
-    use raphtory_storage::{
-        disk::{ParquetLayerCols, Time},
-        graph::graph::GraphStorage,
-    };
-    use rayon::prelude::*;
-    use std::{
-        path::{Path, PathBuf},
-        str::FromStr,
-    };
-    use tempfile::TempDir;
-
-    fn make_simple_graph(graph_dir: impl AsRef<Path>, edges: &[(u64, u64, i64, f64)]) -> Graph {
-        let storage = DiskGraphStorage::make_simple_graph(graph_dir, edges, 1000, 1000);
-        Graph::from(GraphStorage::from(storage))
-    }
-
-    fn check_graph_counts(edges: &[(u64, u64, Time, f64)], g: &impl StaticGraphViewOps) {
-        // check number of nodes
-        let expected_len = edges
-            .iter()
-            .flat_map(|(src, dst, _, _)| vec![*src, *dst])
-            .sorted()
-            .dedup()
-            .count();
-        assert_eq!(g.count_nodes(), expected_len);
-
-        // check number of edges
-        let expected_len = edges
-            .iter()
-            .map(|(src, dst, _, _)| (*src, *dst))
-            .sorted()
-            .dedup()
-            .count();
-        assert_eq!(g.count_edges(), expected_len);
-
-        // get edges back
-        assert!(edges
-            .iter()
-            .all(|(src, dst, _, _)| g.edge(*src, *dst).is_some()));
-
-        assert!(edges.iter().all(|(src, dst, _, _)| g.has_edge(*src, *dst)));
-
-        // check earlies_time
-        let expected = edges.iter().map(|(_, _, t, _)| *t).min().unwrap();
-        assert_eq!(g.earliest_time().unwrap().t(), expected);
-
-        // check latest_time
-        let expected = edges.iter().map(|(_, _, t, _)| *t).max().unwrap();
-        assert_eq!(g.latest_time().unwrap().t(), expected);
-
-        // get edges over window
-
-        let g = g.window(i64::MIN, i64::MAX).layers(Layer::Default).unwrap();
-
-        // get edges back from full windows with all layers
-        assert!(edges
-            .iter()
-            .all(|(src, dst, _, _)| g.edge(*src, *dst).is_some()));
-
-        assert!(edges.iter().all(|(src, dst, _, _)| g.has_edge(*src, *dst)));
-
-        // check earlies_time
-        let expected = edges.iter().map(|(_, _, t, _)| *t).min().unwrap();
-        assert_eq!(g.earliest_time().unwrap().t(), expected);
-
-        // check latest_time
-        let expected = edges.iter().map(|(_, _, t, _)| *t).max().unwrap();
-        assert_eq!(g.latest_time().unwrap().t(), expected);
-    }
-
-    #[test]
-    fn test_1_edge() {
-        let test_dir = tempfile::tempdir().unwrap();
-        let edges = vec![(1u64, 2u64, 0i64, 4.0)];
-        let g = make_simple_graph(test_dir, &edges);
-        check_graph_counts(&edges, &g);
-    }
-
-    #[test]
-    fn test_2_edges() {
-        let test_dir = tempfile::tempdir().unwrap();
-        let edges = vec![(0, 0, 0, 0.0), (4, 1, 2, 0.0)];
-        let g = make_simple_graph(test_dir, &edges);
-        check_graph_counts(&edges, &g);
-    }
-
-    #[test]
-    fn graph_degree_window() {
-        let test_dir = tempfile::tempdir().unwrap();
-        let mut edges = vec![
-            (1u64, 1u64, 0i64, 4.0),
-            (1, 1, 1, 6.0),
-            (1, 2, 1, 1.0),
-            (1, 3, 2, 2.0),
-            (2, 1, -1, 3.0),
-            (3, 2, 7, 5.0),
-        ];
-
-        edges.sort_by_key(|(src, dst, t, _)| (*src, *dst, *t));
-
-        let g = make_simple_graph(test_dir, &edges);
-        let expected = vec![(2, 3, 0), (1, 0, 0), (1, 0, 0)];
-        check_degrees(&g, &expected)
-    }
-
-    fn check_degrees(g: &impl StaticGraphViewOps, expected: &[(usize, usize, usize)]) {
-        let actual = (1..=3)
-            .map(|i| {
-                let v = g.node(i).unwrap();
-                (
-                    v.window(-1, 7).in_degree(),
-                    v.window(1, 7).out_degree(),
-                    0, // v.window(0, 1).degree(), // we don't support both direction edges yet
-                )
-            })
-            .collect::<Vec<_>>();
-
-        assert_eq!(actual, expected);
-    }
-
-    #[test]
-    fn test_windows() {
-        let test_dir = tempfile::tempdir().unwrap();
-        let mut edges = vec![
-            (1u64, 1u64, -2i64, 4.0),
-            (1u64, 2u64, -1i64, 4.0),
-            (1u64, 2u64, 0i64, 4.0),
-            (1u64, 3u64, 1i64, 4.0),
-            (1u64, 4u64, 2i64, 4.0),
-            (1u64, 4u64, 3i64, 4.0),
-        ];
-
-        edges.sort_by_key(|(src, dst, t, _)| (*src, *dst, *t));
-
-        let g = make_simple_graph(test_dir, &edges);
-
-        let w_g = g.window(-1, 0);
-
-        // let actual = w_g.edges().count();
-        // let expected = 1;
-        // assert_eq!(actual, expected);
-
-        let out_v_deg = w_g.nodes().out_degree().iter_values().collect::<Vec<_>>();
-        assert_eq!(out_v_deg, vec![1, 0]);
-
-        let w_g = g.window(-2, 0);
-        let out_v_deg = w_g.nodes().out_degree().iter_values().collect::<Vec<_>>();
-        assert_eq!(out_v_deg, vec![2, 0]);
-
-        let w_g = g.window(-2, 4);
-        let out_v_deg = w_g.nodes().out_degree().iter_values().collect::<Vec<_>>();
-        assert_eq!(out_v_deg, vec![4, 0, 0, 0]);
-
-        let in_v_deg = w_g.nodes().in_degree().iter_values().collect::<Vec<_>>();
-        assert_eq!(in_v_deg, vec![1, 1, 1, 1]);
-    }
-
-    #[test]
-    fn test_temp_props() {
-        let test_dir = tempfile::tempdir().unwrap();
-        let mut edges = vec![
-            (1u64, 2u64, -2i64, 1.0),
-            (1u64, 2u64, -1i64, 2.0),
-            (1u64, 2u64, 0i64, 3.0),
-            (1u64, 2u64, 1i64, 4.0),
-            (1u64, 3u64, 2i64, 1.0),
-            (1u64, 3u64, 3i64, 2.0),
-        ];
-
-        edges.sort_by_key(|(src, dst, t, _)| (*src, *dst, *t));
-
-        let g = make_simple_graph(test_dir, &edges);
-
-        // check all properties
-        let edge_t_props = weight_props(&g);
-
-        assert_eq!(
-            edge_t_props,
-            vec![(-2, 1.0), (-1, 2.0), (0, 3.0), (1, 4.0), (2, 1.0), (3, 2.0)]
-        );
-
-        // window the graph half way
-        let w_g = g.window(-2, 0);
-        let edge_t_props = weight_props(&w_g);
-        assert_eq!(edge_t_props, vec![(-2, 1.0), (-1, 2.0)]);
-
-        // window the other half
-        let w_g = g.window(0, 3);
-        let edge_t_props = weight_props(&w_g);
-        assert_eq!(edge_t_props, vec![(0, 3.0), (1, 4.0), (2, 1.0)]);
-    }
-
-    fn weight_props(g: &impl StaticGraphViewOps) -> Vec<(i64, f64)> {
-        let edge_t_props: Vec<_> = g
-            .edges()
-            .into_iter()
-            .flat_map(|e| {
-                e.properties()
-                    .temporal()
-                    .get("weight")
-                    .into_iter()
-                    .flat_map(|t_prop| t_prop.into_iter().map(|(t, p)| (t.t(), p)))
-            })
-            .filter_map(|(t, t_prop)| t_prop.into_f64().map(|v| (t, v)))
-            .collect();
-        edge_t_props
-    }
-
-    proptest! {
-        #[test]
-        fn test_graph_count_nodes(
-            edges in any_with::<Vec<(u64, u64, Time, f64)>>(size_range(1..=1000).lift()).prop_map(|mut v| {
-                v.sort_by(|(a1, b1, c1, _),(a2, b2, c2, _) | {
-                    (a1, b1, c1).cmp(&(a2, b2, c2))
-                });
-                v
-            })
-        ) {
-            let test_dir = tempfile::tempdir().unwrap();
-            let g = make_simple_graph(test_dir, &edges);
-            check_graph_counts(&edges, &g);
-
-        }
-    }
-
-    #[test]
-    fn test_par_nodes() {
-        let test_dir = TempDir::new().unwrap();
-
-        let mut edges = vec![
-            (1u64, 2u64, -2i64, 1.0),
-            (1u64, 2u64, -1i64, 2.0),
-            (1u64, 2u64, 0i64, 3.0),
-            (1u64, 2u64, 1i64, 4.0),
-            (1u64, 3u64, 2i64, 1.0),
-            (1u64, 3u64, 3i64, 2.0),
-        ];
-
-        edges.sort_by_key(|(src, dst, t, _)| (*src, *dst, *t));
-
-        let g = make_simple_graph(test_dir.path(), &edges);
-
-        assert_eq!(g.nodes().par_iter().count(), g.count_nodes())
-    }
-
-    #[test]
-    fn test_no_prop_nodes() {
-        let test_dir = TempDir::new().unwrap();
-        let g = Graph::new();
-        g.add_node(0, 0, NO_PROPS, None).unwrap();
-        // g.add_node(1, 1, [("test", "test")], None).unwrap();
-        let disk_g = g.persist_as_disk_graph(test_dir.path()).unwrap();
-        assert_eq!(disk_g.node(0).unwrap().earliest_time().unwrap().t(), 0);
-        assert_graph_equal(&g, &disk_g);
-    }
-
-    #[test]
-    fn test_mem_to_disk_graph() {
-        let mem_graph = Graph::new();
-        mem_graph.add_edge(0, 0, 1, [("test", 0u64)], None).unwrap();
-        let test_dir = TempDir::new().unwrap();
-        let disk_graph =
-            TemporalGraph::from_graph(&mem_graph, test_dir.path(), || Ok(Properties::default()))
-                .unwrap();
-        assert_eq!(disk_graph.num_nodes(), 2);
-        assert_eq!(disk_graph.num_edges(), 1);
-    }
-
-    #[test]
-    fn test_node_properties() {
-        let mem_graph = Graph::new();
-        let node = mem_graph
-            .add_node(
-                0,
-                0,
-                [
-                    ("test_num", 0u64.into_prop()),
-                    ("test_str", "test".into_prop()),
-                ],
-                None,
-            )
-            .unwrap();
-        node.add_metadata([
-            ("const_str", "test_c".into_prop()),
-            ("const_float", 0.314f64.into_prop()),
-        ])
-        .unwrap();
-        let test_dir = TempDir::new().unwrap();
-        let disk_graph = mem_graph.persist_as_disk_graph(test_dir.path()).unwrap();
-        assert_eq!(disk_graph.count_nodes(), 1);
-        let props = disk_graph.node(0).unwrap().properties();
-        let metadata = disk_graph.node(0).unwrap().metadata();
-        assert_eq!(props.get("test_num").unwrap_u64(), 0);
-        assert_eq!(props.get("test_str").unwrap_str(), "test");
-        assert_eq!(metadata.get("const_str").unwrap_str(), "test_c");
-        assert_eq!(metadata.get("const_float").unwrap_f64(), 0.314);
-
-        let temp = disk_graph.node(0).unwrap().properties().temporal();
-        assert_eq!(
-            temp.get("test_num").unwrap().latest().unwrap(),
-            0u64.into_prop()
-        );
-        assert_eq!(
-            temp.get("test_str").unwrap().latest().unwrap(),
-            "test".into_prop()
-        );
-
-        drop(disk_graph);
-
-        let disk_graph: Graph = DiskGraphStorage::load_from_dir(test_dir.path())
-            .unwrap()
-            .into();
-        let props = disk_graph.node(0).unwrap().properties();
-        let metadata = disk_graph.node(0).unwrap().metadata();
-        assert_eq!(props.get("test_num").unwrap_u64(), 0);
-        assert_eq!(props.get("test_str").unwrap_str(), "test");
-        assert_eq!(metadata.get("const_str").unwrap_str(), "test_c");
-        assert_eq!(metadata.get("const_float").unwrap_f64(), 0.314);
-
-        let temp = disk_graph.node(0).unwrap().properties().temporal();
-        assert_eq!(
-            temp.get("test_num").unwrap().latest().unwrap(),
-            0u64.into_prop()
-        );
-        assert_eq!(
-            temp.get("test_str").unwrap().latest().unwrap(),
-            "test".into_prop()
-        );
-    }
-
-    #[test]
-    fn test_node_properties_2() {
-        let g = Graph::new();
-        g.add_edge(1, 1u64, 1u64, NO_PROPS, None).unwrap();
-        let props_t1 = [
-            ("prop 1", 1u64.into_prop()),
-            ("prop 3", "hi".into_prop()),
-            ("prop 4", true.into_prop()),
-        ];
-        let v = g.add_node(1, 1u64, props_t1, None).unwrap();
-        let props_t2 = [
-            ("prop 1", 2u64.into_prop()),
-            ("prop 2", 0.6.into_prop()),
-            ("prop 4", false.into_prop()),
-        ];
-        v.add_updates(2, props_t2).unwrap();
-        let props_t3 = [
-            ("prop 2", 0.9.into_prop()),
-            ("prop 3", "hello".into_prop()),
-            ("prop 4", true.into_prop()),
-        ];
-        v.add_updates(3, props_t3).unwrap();
-        v.add_metadata([("static prop", 123)]).unwrap();
-
-        let test_dir = TempDir::new().unwrap();
-        let disk_graph = g.persist_as_disk_graph(test_dir.path()).unwrap();
-
-        let actual = disk_graph
-            .at(2)
-            .node(1u64)
-            .unwrap()
-            .properties()
-            .temporal()
-            .into_iter()
-            .map(|(key, t_view)| {
-                (
-                    key.to_string(),
-                    t_view
-                        .into_iter()
-                        .map(|(t, p)| (t.t(), p))
-                        .collect::<Vec<_>>(),
-                )
-            })
-            .filter(|(_, v)| !v.is_empty())
-            .collect::<Vec<_>>();
-
-        let expected = vec![
-            ("prop 1".to_string(), vec![(2, 2u64.into_prop())]),
-            ("prop 4".to_string(), vec![(2, false.into_prop())]),
-            ("prop 2".to_string(), vec![(2, 0.6.into_prop())]),
-        ];
-
-        assert_eq!(actual, expected);
-    }
-
-    #[test]
-    fn test_only_const_node_properties() {
-        let g = Graph::new();
-        let v = g.add_node(0, 1, NO_PROPS, None).unwrap();
-        v.add_metadata([("test", "test")]).unwrap();
-        let test_dir = TempDir::new().unwrap();
-        let disk_graph = g.persist_as_disk_graph(test_dir.path()).unwrap();
-        assert_eq!(
-            disk_graph
-                .node(1)
-                .unwrap()
-                .metadata()
-                .get("test")
-                .unwrap_str(),
-            "test"
-        );
-        let disk_graph = DiskGraphStorage::load_from_dir(test_dir.path())
-            .unwrap()
-            .into_graph();
-        assert_eq!(
-            disk_graph
-                .node(1)
-                .unwrap()
-                .metadata()
-                .get("test")
-                .unwrap_str(),
-            "test"
-        );
-    }
-
-    #[test]
-    fn test_type_filter_disk_graph_loaded_from_parquets() {
-        let tmp_dir = tempfile::tempdir().unwrap();
-        let graph_dir = tmp_dir.path();
-        let chunk_size = 268_435_456;
-        let num_threads = 4;
-        let t_props_chunk_size = chunk_size / 8;
-
-        let netflow_layer_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
-            .parent()
-            .map(|p| p.join("pometry-storage-private/resources/test/netflow.parquet"))
-            .unwrap();
-
-        let v1_layer_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
-            .parent()
-            .map(|p| p.join("pometry-storage-private/resources/test/wls.parquet"))
-            .unwrap();
-
-        let node_properties = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
-            .parent()
-            .map(|p| p.join("pometry-storage-private/resources/test/node_types.parquet"))
-            .unwrap();
-
-        let layer_parquet_cols = vec![
-            ParquetLayerCols {
-                parquet_dir: netflow_layer_path.to_str().unwrap(),
-                layer: "netflow",
-                src_col: "source",
-                dst_col: "destination",
-                time_col: "time",
-                exclude_edge_props: vec![],
-            },
-            ParquetLayerCols {
-                parquet_dir: v1_layer_path.to_str().unwrap(),
-                layer: "wls",
-                src_col: "src",
-                dst_col: "dst",
-                time_col: "Time",
-                exclude_edge_props: vec![],
-            },
-        ];
-
-        let node_type_col = Some("node_type");
-
-        let g = DiskGraphStorage::load_from_parquets(
-            graph_dir,
-            layer_parquet_cols,
-            Some(&node_properties),
-            chunk_size,
-            t_props_chunk_size,
-            num_threads,
-            node_type_col,
-            None,
-            None,
-        )
-        .unwrap()
-        .into_graph();
-
-        assert_eq!(
-            g.nodes().type_filter(["A"]).name().collect_vec(),
-            vec!["Comp710070", "Comp844043"]
-        );
-
-        assert_eq!(
-            g.nodes()
-                .type_filter(Vec::<String>::new())
-                .name()
-                .collect_vec(),
-            Vec::<String>::new()
-        );
-
-        assert_eq!(
-            g.nodes().type_filter([""]).name().collect_vec(),
-            Vec::<String>::new()
-        );
-
-        assert_eq!(
-            g.nodes()
-                .type_filter(["A"])
-                .neighbours()
-                .name()
-                .map(|n| { n.collect::<Vec<_>>() })
-                .collect_vec(),
-            vec![vec!["Comp844043"], vec!["Comp710070"]]
-        );
-
-        assert_eq!(
-            g.nodes()
-                .type_filter(["A", "B"])
-                .neighbours()
-                .name()
-                .map(|n| { n.collect::<Vec<_>>() })
-                .collect_vec(),
-            vec![vec!["Comp244393"], vec!["Comp844043"], vec!["Comp710070"]]
-        );
-
-        assert_eq!(
-            g.nodes()
-                .type_filter(["C"])
-                .neighbours()
-                .name()
-                .map(|n| { n.collect::<Vec<_>>() })
-                .collect_vec(),
-            Vec::<Vec<&str>>::new()
-        );
-
-        assert_eq!(
-            g.nodes()
-                .type_filter(["A"])
-                .neighbours()
-                .type_filter(["A"])
-                .name()
-                .map(|n| { n.collect::<Vec<_>>() })
-                .collect_vec(),
-            vec![vec!["Comp844043"], vec!["Comp710070"]]
-        );
-
-        assert_eq!(
-            g.nodes()
-                .type_filter(["A"])
-                .neighbours()
-                .type_filter(Vec::<&str>::new())
-                .name()
-                .map(|n| { n.collect::<Vec<_>>() })
-                .collect_vec(),
-            vec![vec![], Vec::<&str>::new()]
-        );
-
-        let w = g.window(6415659, 7387801);
-
-        assert_eq!(
-            w.nodes().type_filter(["A"]).name().collect_vec(),
-            vec!["Comp710070", "Comp844043"]
-        );
-
-        assert_eq!(
-            w.nodes()
-                .type_filter(Vec::<String>::new())
-                .name()
-                .collect_vec(),
-            Vec::<String>::new()
-        );
-
-        assert_eq!(
-            w.nodes().type_filter([""]).name().collect_vec(),
-            Vec::<String>::new()
-        );
-
-        let l = g.layers(["netflow"]).unwrap();
-
-        assert_eq!(
-            l.nodes().type_filter(["A"]).name().collect_vec(),
-            vec!["Comp710070", "Comp844043"]
-        );
-
-        assert_eq!(
-            l.nodes()
-                .type_filter(Vec::<String>::new())
-                .name()
-                .collect_vec(),
-            Vec::<String>::new()
-        );
-
-        assert_eq!(
-            l.nodes().type_filter([""]).name().collect_vec(),
-            Vec::<String>::new()
-        );
-    }
-
-    #[test]
-    fn test_type_filter_disk_graph_created_from_in_memory_graph() {
-        let g = Graph::new();
-        g.add_node(1, 1, NO_PROPS, Some("a")).unwrap();
-        g.add_node(1, 2, NO_PROPS, Some("b")).unwrap();
-        g.add_node(1, 3, NO_PROPS, Some("b")).unwrap();
-        g.add_node(1, 4, NO_PROPS, Some("a")).unwrap();
-        g.add_node(1, 5, NO_PROPS, Some("c")).unwrap();
-        g.add_node(1, 6, NO_PROPS, Some("e")).unwrap();
-        g.add_node(1, 7, NO_PROPS, None).unwrap();
-        g.add_node(1, 8, NO_PROPS, None).unwrap();
-        g.add_node(1, 9, NO_PROPS, None).unwrap();
-        g.add_edge(2, 1, 2, NO_PROPS, Some("a")).unwrap();
-        g.add_edge(2, 3, 2, NO_PROPS, Some("a")).unwrap();
-        g.add_edge(2, 2, 4, NO_PROPS, Some("a")).unwrap();
-        g.add_edge(2, 4, 5, NO_PROPS, Some("a")).unwrap();
-        g.add_edge(2, 4, 5, NO_PROPS, Some("a")).unwrap();
-        g.add_edge(2, 5, 6, NO_PROPS, Some("a")).unwrap();
-        g.add_edge(2, 3, 6, NO_PROPS, Some("a")).unwrap();
-
-        let tmp_dir = tempfile::tempdir().unwrap();
-        let g = DiskGraphStorage::from_graph(&g, tmp_dir.path())
-            .unwrap()
-            .into_graph();
-
-        assert_eq!(
-            g.nodes()
-                .type_filter(["a", "b", "c", "e"])
-                .name()
-                .collect_vec(),
-            vec!["1", "2", "3", "4", "5", "6"]
-        );
-
-        assert_eq!(
-            g.nodes()
-                .type_filter(Vec::<String>::new())
-                .name()
-                .collect_vec(),
-            Vec::<String>::new()
-        );
-
-        assert_eq!(
-            g.nodes().type_filter([""]).name().collect_vec(),
-            vec!["7", "8", "9"]
-        );
-
-        let g = DiskGraphStorage::load_from_dir(tmp_dir.path())
-            .unwrap()
-            .into_graph();
-
-        assert_eq!(
-            g.nodes()
-                .type_filter(["a", "b", "c", "e"])
-                .name()
-                .collect_vec(),
-            vec!["1", "2", "3", "4", "5", "6"]
-        );
-
-        assert_eq!(
-            g.nodes()
-                .type_filter(Vec::<String>::new())
-                .name()
-                .collect_vec(),
-            Vec::<String>::new()
-        );
-
-        assert_eq!(
-            g.nodes().type_filter([""]).name().collect_vec(),
-            vec!["7", "8", "9"]
-        );
-    }
-
-    #[test]
-    fn test_reload() {
-        let graph_dir = TempDir::new().unwrap();
-        let graph = Graph::new();
-        graph.add_edge(0, 0, 1, [("weight", 0.)], None).unwrap();
-        graph.add_edge(1, 0, 1, [("weight", 1.)], None).unwrap();
-        graph.add_edge(2, 0, 1, [("weight", 2.)], None).unwrap();
-        graph.add_edge(3, 1, 2, [("weight", 3.)], None).unwrap();
-        let disk_graph = graph.persist_as_disk_graph(graph_dir.path()).unwrap();
-        // persisted graphs have different event ids on time entries
-        assert_graph_equal_timestamps(&disk_graph, &graph);
-
-        let reloaded_graph = DiskGraphStorage::load_from_dir(graph_dir.path())
-            .unwrap()
-            .into_graph();
-        assert_graph_equal_timestamps(&reloaded_graph, &graph);
-    }
-
-    #[test]
-    fn test_load_node_types() {
-        let graph_dir = TempDir::new().unwrap();
-        let graph = Graph::new();
-        graph.add_edge(0, 0, 1, NO_PROPS, None).unwrap();
-        let mut dg = DiskGraphStorage::from_graph(&graph, graph_dir.path()).unwrap();
-        dg.load_node_types_from_arrays(
-            [Ok(StringArray::from_iter_values(["1", "2"]).as_array_ref())],
-            100,
-        )
-        .unwrap();
-        assert_eq!(
-            dg.into_graph().nodes().node_type().collect_vec(),
-            [Some("1".into()), Some("2".into())]
-        );
-    }
-
-    #[test]
-    fn test_node_type() {
-        let graph_dir = TempDir::new().unwrap();
-        let graph = Graph::new();
-        graph.add_node(0, 0, NO_PROPS, Some("1")).unwrap();
-        graph.add_node(0, 1, NO_PROPS, Some("2")).unwrap();
-        graph.add_edge(0, 0, 1, NO_PROPS, None).unwrap();
-        let dg = graph.persist_as_disk_graph(graph_dir.path()).unwrap();
-        assert_eq!(
-            dg.nodes().node_type().collect_vec(),
-            [Some("1".into()), Some("2".into())]
-        );
-        let dg = DiskGraphStorage::load_from_dir(graph_dir.path()).unwrap();
-        assert_eq!(
-            dg.into_graph().nodes().node_type().collect_vec(),
-            [Some("1".into()), Some("2".into())]
-        );
-    }
-    mod addition_bounds {
-        use proptest::prelude::*;
-        use raphtory::{
-            db::graph::graph::assert_graph_equal_timestamps,
-            prelude::*,
-            test_utils::{build_edge_list, build_graph_from_edge_list},
-        };
-        use raphtory_storage::disk::DiskGraphStorage;
-        use tempfile::TempDir;
-
-        #[test]
-        fn test_load_from_graph_missing_edge() {
-            let g = Graph::new();
-            g.add_edge(0, 1, 2, [("test", "test1")], Some("1")).unwrap();
-            g.add_edge(1, 2, 3, [("test", "test2")], Some("2")).unwrap();
-            let test_dir = TempDir::new().unwrap();
-            let disk_g = g.persist_as_disk_graph(test_dir.path()).unwrap();
-            // persisted graphs have different event ids on time entries
-            assert_graph_equal_timestamps(&disk_g, &g);
-        }
-
-        #[test]
-        fn disk_graph_persist_proptest() {
-            proptest!(|(edges in build_edge_list(100, 10))| {
-                let g = build_graph_from_edge_list(&edges);
-                let test_dir = TempDir::new().unwrap();
-                let disk_g = g.persist_as_disk_graph(test_dir.path()).unwrap();
-                // persisted graphs have different event ids on time entries
-                assert_graph_equal_timestamps(&disk_g, &g);
-                let reloaded_disk_g = DiskGraphStorage::load_from_dir(test_dir.path()).unwrap().into_graph();
-                assert_graph_equal_timestamps(&reloaded_disk_g, &g);
-            } )
-        }
-    }
-
-    #[test]
-    fn load_decimal_column() {
-        let parquet_file_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
-            .join("resources/test/data_0.parquet")
-            .to_string_lossy()
-            .to_string();
-
-        let graph_dir = tempfile::tempdir().unwrap();
-
-        let layer_parquet_cols = vec![ParquetLayerCols {
-            parquet_dir: parquet_file_path.as_ref(),
-            layer: "large",
-            src_col: "from_address",
-            dst_col: "to_address",
-            time_col: "block_timestamp",
-            exclude_edge_props: vec![],
-        }];
-        let dgs = DiskGraphStorage::load_from_parquets(
-            graph_dir.path(),
-            layer_parquet_cols,
-            None,
-            100,
-            100,
-            1,
-            None,
-            None,
-            None,
-        )
-        .unwrap();
-
-        let g = dgs.into_graph();
-        let (_, actual): (Vec<_>, Vec<_>) = g
-            .edges()
-            .properties()
-            .flat_map(|props| props.temporal().into_iter())
-            .flat_map(|(_, view)| view.into_iter())
-            .unzip();
-
-        let expected = [
-            "20000000000000000000.000000000",
-            "20000000000000000000.000000000",
-            "20000000000000000000.000000000",
-            "24000000000000000000.000000000",
-            "20000000000000000000.000000000",
-            "104447267751554560119.000000000",
-            "42328815976923864739.000000000",
-            "23073375143032303343.000000000",
-            "23069234889247394908.000000000",
-            "18729358881519682914.000000000",
-        ]
-        .into_iter()
-        .map(|s| BigDecimal::from_str(s).map(Prop::Decimal))
-        .collect::<Result<Vec<_>, _>>()
-        .unwrap();
-
-        assert_eq!(actual, expected);
-    }
-}
-
-#[cfg(feature = "storage")]
-#[cfg(test)]
-mod storage_tests {
-    use std::collections::BTreeSet;
-
-    use itertools::Itertools;
-    use proptest::prelude::*;
-    use tempfile::TempDir;
-
-    use raphtory::{
-        db::graph::graph::{assert_graph_equal, assert_graph_equal_timestamps},
-        prelude::{AdditionOps, Graph, GraphViewOps, NodeViewOps, NO_PROPS, *},
-    };
-    use raphtory_api::core::storage::{arc_str::OptionAsStr, timeindex::AsTime};
-    use raphtory_core::entities::nodes::node_ref::AsNodeRef;
-    use raphtory_storage::{disk::DiskGraphStorage, mutation::addition_ops::InternalAdditionOps};
-
-    #[test]
-    fn test_merge() {
-        let g1 = Graph::new();
-        g1.add_node(0, 0, [("node_prop", 0f64)], Some("1")).unwrap();
-        g1.add_node(0, 1, NO_PROPS, None).unwrap();
-        g1.add_node(0, 2, [("node_prop", 2f64)], Some("2")).unwrap();
-        g1.add_edge(1, 0, 1, [("test", 1i32)], None).unwrap();
-        g1.add_edge(2, 0, 1, [("test", 2i32)], Some("1")).unwrap();
-        g1.add_edge(2, 1, 2, [("test2", "test")], None).unwrap();
-        g1.node(1)
-            .unwrap()
-            .add_metadata([("const_str", "test")])
-            .unwrap();
-        g1.node(0)
-            .unwrap()
-            .add_updates(3, [("test", "test")])
-            .unwrap();
-
-        let g2 = Graph::new();
-        g2.add_node(1, 0, [("node_prop", 1f64)], None).unwrap();
-        g2.add_node(0, 1, NO_PROPS, None).unwrap();
-        g2.add_node(3, 2, [("node_prop", 3f64)], Some("3")).unwrap();
-        g2.add_edge(1, 0, 1, [("test", 2i32)], None).unwrap();
-        g2.add_edge(3, 0, 1, [("test", 3i32)], Some("2")).unwrap();
-        g2.add_edge(2, 1, 2, [("test2", "test")], None).unwrap();
-        g2.node(1)
-            .unwrap()
-            .add_metadata([("const_str2", "test2")])
-            .unwrap();
-        g2.node(0)
-            .unwrap()
-            .add_updates(3, [("test", "test")])
-            .unwrap();
-        let g1_dir = TempDir::new().unwrap();
-        let g2_dir = TempDir::new().unwrap();
-        let gm_dir = TempDir::new().unwrap();
-
-        let g1_a = DiskGraphStorage::from_graph(&g1, g1_dir.path()).unwrap();
-        let g2_a = DiskGraphStorage::from_graph(&g2, g2_dir.path()).unwrap();
-
-        let gm = g1_a
-            .merge_by_sorted_gids(&g2_a, &gm_dir)
-            .unwrap()
-            .into_graph();
-
-        let n0 = gm.node(0).unwrap();
-        assert_eq!(
-            n0.properties()
-                .temporal()
-                .get("node_prop")
-                .unwrap()
-                .iter()
-                .map(|(t, p)| (t.t(), p))
-                .collect_vec(),
-            [(0, Prop::F64(0.)), (1, Prop::F64(1.))]
-        );
-        assert_eq!(
-            n0.properties()
-                .temporal()
-                .get("test")
-                .unwrap()
-                .iter()
-                .map(|(t, p)| (t.t(), p))
-                .collect_vec(),
-            [(3, Prop::str("test")), (3, Prop::str("test"))]
-        );
-        assert_eq!(n0.node_type().as_str(), Some("1"));
-        let n1 = gm.node(1).unwrap();
-        assert_eq!(n1.metadata().get("const_str"), Some(Prop::str("test")));
-        assert_eq!(n1.metadata().get("const_str2").unwrap_str(), "test2");
-        assert!(n1
-            .properties()
-            .temporal()
-            .values()
-            .all(|prop| prop.values().next().is_none()));
-        let n2 = gm.node(2).unwrap();
-        assert_eq!(n2.node_type().as_str(), Some("3")); // right has priority
-
-        assert_eq!(
-            gm.default_layer()
-                .edges()
-                .id()
-                .filter_map(|(a, b)| a.as_u64().zip(b.as_u64()))
-                .collect::<Vec<_>>(),
-            [(0, 1), (1, 2)]
-        );
-        assert_eq!(
-            gm.valid_layers("1")
-                .edges()
-                .id()
-                .filter_map(|(a, b)| a.as_u64().zip(b.as_u64()))
-                .collect::<Vec<_>>(),
-            [(0, 1)]
-        );
-        assert_eq!(
-            gm.valid_layers("2")
-                .edges()
-                .id()
-                .filter_map(|(a, b)| a.as_u64().zip(b.as_u64()))
-                .collect::<Vec<_>>(),
-            [(0, 1)]
-        );
-    }
-
-    fn add_edges(g: &Graph, edges: &[(i64, u64, u64)]) {
-        let nodes: BTreeSet<_> = edges
-            .iter()
-            .flat_map(|(_, src, dst)| [*src, *dst])
-            .collect();
-        for n in nodes {
-            g.resolve_node(n.as_node_ref()).unwrap();
-        }
-        for (t, src, dst) in edges {
-            g.add_edge(*t, *src, *dst, NO_PROPS, None).unwrap();
-        }
-    }
-
-    fn inner_merge_test(left_edges: &[(i64, u64, u64)], right_edges: &[(i64, u64, u64)]) {
-        let left_g = Graph::new();
-        add_edges(&left_g, left_edges);
-        let right_g = Graph::new();
-        add_edges(&right_g, right_edges);
-        let merged_g_expected = Graph::new();
-        add_edges(&merged_g_expected, left_edges);
-        add_edges(&merged_g_expected, right_edges);
-
-        let left_dir = TempDir::new().unwrap();
-        let right_dir = TempDir::new().unwrap();
-        let merged_dir = TempDir::new().unwrap();
-
-        let left_g_disk = DiskGraphStorage::from_graph(&left_g, left_dir.path()).unwrap();
-        let right_g_disk = DiskGraphStorage::from_graph(&right_g, right_dir.path()).unwrap();
-
-        let merged_g_disk = left_g_disk
-            .merge_by_sorted_gids(&right_g_disk, &merged_dir)
-            .unwrap();
-        // only check timestamps because event ids might be different based on order of edge added
-        assert_graph_equal_timestamps(&merged_g_disk.into_graph(), &merged_g_expected)
-    }
-
-    #[test]
-    fn test_merge_proptest() {
-        proptest!(|(left_edges in prop::collection::vec((0i64..10, 0u64..10, 0u64..10), 0..=100), right_edges in prop::collection::vec((0i64..10, 0u64..10, 0u64..10), 0..=100))| {
-            inner_merge_test(&left_edges, &right_edges)
-        })
-    }
-
-    #[test]
-    fn test_merge_simple() {
-        let left = [(4, 4, 2), (4, 4, 2)];
-        let right = [];
-        inner_merge_test(&left, &right);
-
-        let left = [(0, 5, 5)];
-        let right = [];
-        inner_merge_test(&left, &right);
-
-        let left = [(0, 0, 0), (0, 0, 0), (0, 0, 0)];
-        let right = [];
-        inner_merge_test(&left, &right);
-
-        let left = [(0, 0, 0), (0, 0, 0), (0, 0, 0)];
-        let right = [(0, 0, 0)];
-        inner_merge_test(&left, &right);
-    }
-
-    #[test]
-    fn test_one_empty_graph_non_zero_time() {
-        inner_merge_test(&[], &[(1, 0, 0)])
-    }
-    #[test]
-    fn test_empty_graphs() {
-        inner_merge_test(&[], &[])
-    }
-
-    #[test]
-    fn test_one_empty_graph() {
-        inner_merge_test(&[], &[(0, 0, 0)])
-    }
-
-    #[test]
-    fn inbounds_not_merging() {
-        inner_merge_test(&[], &[(0, 0, 0), (0, 0, 1), (0, 0, 2)])
-    }
-
-    #[test]
-    fn inbounds_not_merging_take2() {
-        inner_merge_test(
-            &[(0, 0, 2)],
-            &[
-                (0, 1, 0),
-                (0, 0, 0),
-                (0, 0, 0),
-                (0, 0, 0),
-                (0, 0, 0),
-                (0, 0, 0),
-                (0, 0, 0),
-            ],
-        )
-    }
-
-    #[test]
-    fn offsets_panic_overflow() {
-        inner_merge_test(
-            &[
-                (0, 0, 4),
-                (0, 0, 4),
-                (0, 0, 0),
-                (0, 0, 4),
-                (0, 1, 2),
-                (0, 3, 4),
-            ],
-            &[(0, 0, 5), (0, 2, 0)],
-        )
-    }
-
-    #[test]
-    fn inbounds_not_merging_take3() {
-        inner_merge_test(
-            &[
-                (0, 0, 4),
-                (0, 0, 4),
-                (0, 0, 0),
-                (0, 0, 4),
-                (0, 1, 2),
-                (0, 3, 4),
-            ],
-            &[(0, 0, 3), (0, 0, 4), (0, 2, 2), (0, 0, 5), (0, 0, 6)],
-        )
-    }
-}
diff --git a/raphtory/tests/edge_property_filter.rs b/raphtory/tests/edge_property_filter.rs
index 1971704854..06bb051190 100644
--- a/raphtory/tests/edge_property_filter.rs
+++ b/raphtory/tests/edge_property_filter.rs
@@ -4,7 +4,7 @@ use raphtory::{
     db::{
         api::view::Filter,
         graph::{
-            assertions::assert_ok_or_missing_edges,
+            assertions::{assert_ok_or_missing_edges, EdgeRow},
             graph::{assert_graph_equal, assert_persistent_materialize_graph_equal},
             views::{
                 deletion_graph::PersistentGraph,
@@ -19,7 +19,7 @@ use raphtory::{
     test_utils::{build_edge_deletions, build_edge_list, build_graph_from_edge_list, build_window},
 };
 use raphtory_api::core::{entities::properties::prop::PropType, storage::timeindex::AsTime};
-use raphtory_storage::mutation::addition_ops::InternalAdditionOps;
+use raphtory_storage::mutation::addition_ops::{InternalAdditionOps, SessionAdditionOps};
 
 #[test]
 fn test_edge_filter() {
@@ -264,27 +264,49 @@ fn test_graph_materialise_window() {
     })
 }
 
+fn check_persistent_graph_mat_window(
+    edges: &[EdgeRow],
+    edge_deletions: Vec<(u64, u64, i64)>,
+    v: i64,
+    (start, end): (i64, i64),
+) {
+    let g = build_graph_from_edge_list(edges);
+    let g = g.persistent_graph();
+    for (src, dst, t) in edge_deletions {
+        g.delete_edge(t, src, dst, None).unwrap();
+    }
+    let filter = EdgeFilter.property("int_prop").gt(v);
+    assert_ok_or_missing_edges(
+        edges,
+        g.window(start, end).filter(filter.clone()),
+        |filtered| {
+            let gwfm = filtered.materialize().unwrap();
+            assert_persistent_materialize_graph_equal(&filtered, &gwfm);
+        },
+    );
+    assert_ok_or_missing_edges(edges, g.filter(filter.clone()), |filtered| {
+        let gfw = filtered.window(start, end);
+        let gfwm = gfw.materialize().unwrap();
+        assert_persistent_materialize_graph_equal(&gfw, &gfwm);
+    });
+}
+
 #[test]
 fn test_persistent_graph_materialise_window() {
     proptest!(|(edges in build_edge_list(100, 100), edge_deletions in build_edge_deletions(100, 100), v in any::<i64>(), (start, end) in build_window())| {
-        let g = build_graph_from_edge_list(&edges);
-        let g = g.persistent_graph();
-        for (src, dst, t) in edge_deletions {
-            g.delete_edge(t, src, dst, None).unwrap();
-        }
-        let filter = EdgeFilter.property("int_prop").gt(v);
-        assert_ok_or_missing_edges(&edges, g.window(start, end).filter(filter.clone()), |filtered| {
-            let gwfm = filtered.materialize().unwrap();
-            assert_persistent_materialize_graph_equal(&filtered, &gwfm);
-        });
-        assert_ok_or_missing_edges(&edges, g.filter(filter.clone()), |filtered| {
-            let gfw = filtered.window(start, end);
-            let gfwm = gfw.materialize().unwrap();
-            assert_persistent_materialize_graph_equal(&gfw, &gfwm);
-        });
+        check_persistent_graph_mat_window(&edges, edge_deletions, v, (start, end));
     })
 }
 
+#[test]
+fn simplte_graph_materialize_window() {
+    let edges = [(0, 0, 0, "".to_owned(), 0), (0, 0, 0, "".to_owned(), 0)];
+    let edge_deletions = vec![];
+    let start_end = (1, 2);
+    let v = -1;
+    check_persistent_graph_mat_window(&edges, edge_deletions, v, start_end);
+}
+
 #[test]
 fn test_single_unfiltered_edge_empty_window_persistent() {
     let g = PersistentGraph::new();
@@ -298,6 +320,8 @@ fn test_single_unfiltered_edge_empty_window_persistent() {
     assert_eq!(gw.count_edges(), 0);
     let expected = PersistentGraph::new();
     expected
+        .write_session()
+        .unwrap()
         .resolve_edge_property("test", PropType::I64, false)
         .unwrap();
     expected.resolve_layer(None).unwrap();
diff --git a/raphtory/tests/exploded_edge_property_filter.rs b/raphtory/tests/exploded_edge_property_filter.rs
index 71eb14b790..8f993e8f24 100644
--- a/raphtory/tests/exploded_edge_property_filter.rs
+++ b/raphtory/tests/exploded_edge_property_filter.rs
@@ -30,7 +30,10 @@ use raphtory_api::core::{
     storage::{arc_str::ArcStr, timeindex::AsTime},
 };
 use raphtory_core::entities::nodes::node_ref::AsNodeRef;
-use raphtory_storage::{core_ops::CoreGraphOps, mutation::addition_ops::InternalAdditionOps};
+use raphtory_storage::{
+    core_ops::CoreGraphOps,
+    mutation::addition_ops::{InternalAdditionOps, SessionAdditionOps},
+};
 use std::collections::HashMap;
 
 fn build_filtered_graph(
@@ -45,7 +48,7 @@ fn build_filtered_graph(
                 *src,
                 *dst,
                 [
-                    ("str_prop", str_prop.into()),
+                    ("str_prop", Prop::str(str_prop.as_ref())),
                     ("int_prop", Prop::I64(*int_prop)),
                 ],
                 None,
@@ -71,15 +74,15 @@ fn build_filtered_nodes_graph(
                 *src,
                 *dst,
                 [
-                    ("str_prop", str_prop.into()),
+                    ("str_prop", str_prop.as_str().into()),
                     ("int_prop", Prop::I64(*int_prop)),
                 ],
                 None,
             )
             .unwrap();
         }
-        g.resolve_node(src.as_node_ref()).unwrap();
-        g.resolve_node(dst.as_node_ref()).unwrap();
+        g.atomic_add_node(src.as_node_ref()).unwrap();
+        g.atomic_add_node(dst.as_node_ref()).unwrap();
     }
     if !edges.is_empty() {
         g.resolve_layer(None).unwrap();
@@ -131,10 +134,11 @@ fn build_filtered_persistent_graph(
                     } else {
                         g_filtered.delete_edge(t, src, dst, None).unwrap();
                         // properties still exist after filtering
-                        g_filtered
+                        let session = g_filtered.write_session().unwrap();
+                        session
                             .resolve_edge_property("str_prop", PropType::Str, false)
                             .unwrap();
-                        g_filtered
+                        session
                             .resolve_edge_property("int_prop", PropType::I64, false)
                             .unwrap();
                     }
@@ -256,6 +260,8 @@ fn test_filter_persistent_single_filtered_edge() {
     expected.delete_edge(0, 0, 0, None).unwrap();
     //the property still exists!
     expected
+        .write_session()
+        .unwrap()
         .resolve_edge_property("test", PropType::I64, false)
         .unwrap();
 
@@ -342,6 +348,15 @@ fn test_filter_eq() {
     })
 }
 
+#[test]
+fn test_filter_eq_one_edge() {
+    let g = Graph::new();
+    g.add_edge(0, 0, 0, [("int_prop", Prop::I64(0))], None)
+        .unwrap();
+    let filter = ExplodedEdgeFilter.property("int_prop").eq(0i64);
+    assert_graph_equal(&g.filter(filter.clone()).unwrap(), &g);
+}
+
 #[test]
 fn test_filter_eq_persistent() {
     proptest!(|(
@@ -463,6 +478,7 @@ fn test_filter_persistent_materialise_is_consistent() {
 }
 
 #[test]
+#[ignore = "need a way to add a node without timestamp"]
 fn test_filter_on_nodes() {
     proptest!(|(
         edges in build_edge_list(100, 100), v in any::<i64>()
@@ -476,6 +492,19 @@ fn test_filter_on_nodes() {
     })
 }
 
+#[test]
+#[ignore = "need a way to add a node without timestamp"]
+fn test_filter_on_nodes_simple() {
+    let edges = [(1u64, 2u64, 0i64, "a".to_string(), 10i64)];
+    let v = -1;
+    let g = build_graph_from_edge_list(&edges);
+    let filter = ExplodedEdgeFilter.property("int_prop").eq(v);
+    assert_ok_or_missing_edges(&edges, g.nodes().filter(filter.clone()), |filtered| {
+        let expected_filtered_g = build_filtered_nodes_graph(&edges, |vv| vv == v);
+        assert_nodes_equal(&filtered, &expected_filtered_g.nodes());
+    });
+}
+
 #[test]
 fn test_filter_on_node() {
     proptest!(|(
diff --git a/raphtory/tests/node_property_filter.rs b/raphtory/tests/node_property_filter.rs
index ecb9b7ae89..cb2385efd7 100644
--- a/raphtory/tests/node_property_filter.rs
+++ b/raphtory/tests/node_property_filter.rs
@@ -2,53 +2,34 @@ use itertools::Itertools;
 use proptest::{arbitrary::any, proptest};
 use raphtory::{
     db::{
-        api::{
-            properties::internal::InheritPropertiesOps,
-            state::ops::NodeOp,
-            view::{
-                filter_ops::{Filter, NodeSelect},
-                internal::{
-                    GraphView, Immutable, InheritAllEdgeFilterOps, InheritEdgeHistoryFilter,
-                    InheritLayerOps, InheritListOps, InheritMaterialize, InheritNodeHistoryFilter,
-                    InheritStorageOps, InheritTimeSemantics, InternalNodeFilterOps, Static,
-                },
-                EdgeSelect,
-            },
-        },
+        api::view::filter_ops::{Filter, NodeSelect},
         graph::{
             assertions::assert_ok_or_missing_nodes,
             graph::assert_edges_equal,
-            views::filter::{
-                model::{
-                    node_filter::{ops::NodeFilterOps, NodeFilter},
-                    property_filter::ops::PropertyFilterOps,
-                    ComposableFilter, PropertyFilterFactory,
-                },
-                CreateFilter,
+            views::filter::model::{
+                node_filter::{ops::NodeFilterOps, NodeFilter},
+                property_filter::ops::PropertyFilterOps,
+                ComposableFilter, PropertyFilterFactory,
             },
         },
     },
-    prelude::{AdditionOps, Graph, GraphViewOps, TimeOps, NO_PROPS, *},
+    prelude::*,
     test_utils::{
         add_node_props, build_edge_list, build_graph_from_edge_list, build_node_props,
         node_filtered_graph,
     },
 };
-use raphtory_api::{core::storage::timeindex::AsTime, inherit::Base};
-use raphtory_storage::{
-    core_ops::{CoreGraphOps, InheritCoreGraphOps},
-    layer_ops::InternalLayerOps,
-};
+
 #[test]
 #[ignore]
 // TODO: Enable this once fixed
 fn test_node_filter_on_nodes() {
     let g = Graph::new();
-    g.add_node(0, "Jimi", [("band", "JH Experience")], None)
+    g.add_node(0, "Jimi", [("band", "JH Experience")], None, None)
         .unwrap();
-    g.add_node(1, "John", [("band", "Dead & Company")], None)
+    g.add_node(1, "John", [("band", "Dead & Company")], None, None)
         .unwrap();
-    g.add_node(2, "David", [("band", "Pink Floyd")], None)
+    g.add_node(2, "David", [("band", "Pink Floyd")], None, None)
         .unwrap();
 
     let filter_expr = NodeFilter::name()
@@ -88,10 +69,10 @@ fn test_node_filter_on_nodes() {
 #[test]
 fn test_node_property_filter_on_nodes() {
     let g = Graph::new();
-    g.add_node(0, 1, [("test", 1i64)], None).unwrap();
-    g.add_node(0, 2, [("test", 2i64)], None).unwrap();
-    g.add_node(1, 3, [("test", 3i64)], None).unwrap();
-    g.add_node(1, 4, [("test", 4i64)], None).unwrap();
+    g.add_node(0, 1, [("test", 1i64)], None, None).unwrap();
+    g.add_node(0, 2, [("test", 2i64)], None, None).unwrap();
+    g.add_node(1, 3, [("test", 3i64)], None, None).unwrap();
+    g.add_node(1, 4, [("test", 4i64)], None, None).unwrap();
 
     g.add_edge(0, 1, 2, NO_PROPS, None).unwrap();
     g.add_edge(1, 2, 3, NO_PROPS, None).unwrap();
@@ -182,9 +163,9 @@ fn test_node_property_filter_on_nodes() {
 #[test]
 fn test_node_property_filter_path() {
     let g = Graph::new();
-    g.add_node(0, 1, [("test", 1i64)], None).unwrap();
-    g.add_node(1, 2, [("test", 2i64)], None).unwrap();
-    g.add_node(1, 3, [("test", 3i64)], None).unwrap();
+    g.add_node(0, 1, [("test", 1i64)], None, None).unwrap();
+    g.add_node(1, 2, [("test", 2i64)], None, None).unwrap();
+    g.add_node(1, 3, [("test", 3i64)], None, None).unwrap();
     g.add_edge(0, 1, 2, NO_PROPS, None).unwrap();
     g.add_edge(1, 2, 3, NO_PROPS, None).unwrap();
     g.add_edge(1, 2, 1, NO_PROPS, None).unwrap();
@@ -198,7 +179,8 @@ fn test_node_property_filter_path() {
         filtered_nodes
             .out_neighbours()
             .id()
-            .map(|i| i.collect_vec())
+            .sorted_by_key(|(n, _)| n.id())
+            .map(|(_, i)| i.sorted().collect_vec())
             .collect_vec(),
         vec![vec![GID::U64(1), GID::U64(3)], vec![]]
     );
@@ -207,7 +189,8 @@ fn test_node_property_filter_path() {
         filtered_nodes
             .out_neighbours()
             .degree()
-            .map(|i| i.collect_vec())
+            .sorted_by_key(|(n, _)| n.id())
+            .map(|(_, i)| i.collect_vec())
             .collect_vec(),
         vec![vec![2, 2], vec![]]
     );
@@ -221,7 +204,8 @@ fn test_node_property_filter_path() {
         filtered_nodes_p
             .out_neighbours()
             .id()
-            .map(|i| i.collect_vec())
+            .sorted_by_key(|(n, _)| n.id())
+            .map(|(_, i)| i.sorted().collect_vec())
             .collect_vec(),
         vec![vec![GID::U64(1), GID::U64(3)], vec![]]
     );
@@ -230,9 +214,9 @@ fn test_node_property_filter_path() {
 #[test]
 fn test_node_property_filter_on_graph() {
     let g = Graph::new();
-    g.add_node(0, 1, [("test", 1i64)], None).unwrap();
-    g.add_node(1, 2, [("test", 2i64)], None).unwrap();
-    g.add_node(1, 3, [("test", 3i64)], None).unwrap();
+    g.add_node(0, 1, [("test", 1i64)], None, None).unwrap();
+    g.add_node(1, 2, [("test", 2i64)], None, None).unwrap();
+    g.add_node(1, 3, [("test", 3i64)], None, None).unwrap();
     g.add_edge(0, 1, 2, NO_PROPS, None).unwrap();
     g.add_edge(1, 2, 3, NO_PROPS, None).unwrap();
     g.add_edge(1, 2, 1, NO_PROPS, None).unwrap();
@@ -451,16 +435,16 @@ fn test_filter_is_none() {
 fn test_filter_is_none_simple_graph() {
     let graph = Graph::new();
     graph
-        .add_node(1, 1, [("p1", 1), ("p2", 2)], Some("fire_nation"))
+        .add_node(1, 1, [("p1", 1), ("p2", 2)], Some("fire_nation"), None)
         .unwrap();
     graph
-        .add_node(2, 1, [("p6", 6)], Some("fire_nation"))
+        .add_node(2, 1, [("p6", 6)], Some("fire_nation"), None)
         .unwrap();
     graph
-        .add_node(2, 2, [("p4", 5)], Some("fire_nation"))
+        .add_node(2, 2, [("p4", 5)], Some("fire_nation"), None)
         .unwrap();
     graph
-        .add_node(3, 3, [("p2", 4), ("p3", 3)], Some("water_tribe"))
+        .add_node(3, 3, [("p2", 4), ("p3", 3)], Some("water_tribe"), None)
         .unwrap();
 
     assert_eq!(graph.count_nodes(), 3);
diff --git a/raphtory/tests/node_test.rs b/raphtory/tests/node_test.rs
index d6cbfa72c7..2a2c607bc3 100644
--- a/raphtory/tests/node_test.rs
+++ b/raphtory/tests/node_test.rs
@@ -1,4 +1,12 @@
-use raphtory::{prelude::*, test_storage, test_utils::test_graph};
+use raphtory::{
+    db::{
+        api::view::Filter,
+        graph::views::filter::model::{NodeViewFilterOps, ViewWrapOps},
+    },
+    prelude::*,
+    test_storage,
+    test_utils::test_graph,
+};
 use raphtory_api::core::storage::arc_str::ArcStr;
 use raphtory_core::storage::timeindex::AsTime;
 use std::collections::HashMap;
@@ -6,9 +14,9 @@ use std::collections::HashMap;
 #[test]
 fn test_earliest_time() {
     let graph = Graph::new();
-    graph.add_node(0, 1, NO_PROPS, None).unwrap();
-    graph.add_node(1, 1, NO_PROPS, None).unwrap();
-    graph.add_node(2, 1, NO_PROPS, None).unwrap();
+    graph.add_node(0, 1, NO_PROPS, None, None).unwrap();
+    graph.add_node(1, 1, NO_PROPS, None, None).unwrap();
+    graph.add_node(2, 1, NO_PROPS, None, None).unwrap();
 
     // FIXME: Node add without properties not showing up (Issue #46)
     test_graph(&graph, |graph| {
@@ -38,8 +46,8 @@ fn test_earliest_time() {
 fn test_properties() {
     let graph = Graph::new();
     let props = [("test", "test")];
-    graph.add_node(0, 1, NO_PROPS, None).unwrap();
-    graph.add_node(2, 1, props, None).unwrap();
+    graph.add_node(0, 1, NO_PROPS, None, None).unwrap();
+    graph.add_node(2, 1, props, None, None).unwrap();
 
     // FIXME: Node add without properties not showing up (Issue #46)
     test_graph(&graph, |graph| {
@@ -47,7 +55,9 @@ fn test_properties() {
         let v1_w = graph.window(0, 1).node(1).unwrap();
         assert_eq!(
             v1.properties().as_map(),
-            [(ArcStr::from("test"), Prop::str("test"))].into()
+            [(ArcStr::from("test"), Prop::str("test"))]
+                .into_iter()
+                .collect::<HashMap<_, _>>()
         );
         assert_eq!(v1_w.properties().as_map(), HashMap::default())
     });
@@ -57,15 +67,15 @@ fn test_properties() {
 fn test_property_additions() {
     let graph = Graph::new();
     let props = [("test", "test")];
-    let v1 = graph.add_node(0, 1, NO_PROPS, None).unwrap();
-    v1.add_updates(2, props).unwrap();
+    let v1 = graph.add_node(0, 1, NO_PROPS, None, None).unwrap();
+    v1.add_updates(2, props, None).unwrap();
     let v1_w = v1.window(0, 1);
     assert_eq!(
         v1.properties().as_map(),
         props
             .into_iter()
-            .map(|(k, v)| (k.into(), v.into_prop()))
-            .collect()
+            .map(|(k, v)| (ArcStr::from(k), v.into_prop()))
+            .collect::<HashMap<_, _>>()
     );
     assert_eq!(v1_w.properties().as_map(), HashMap::default())
 }
@@ -73,7 +83,7 @@ fn test_property_additions() {
 #[test]
 fn test_metadata_additions() {
     let g = Graph::new();
-    let v1 = g.add_node(0, 1, NO_PROPS, None).unwrap();
+    let v1 = g.add_node(0, 1, NO_PROPS, None, None).unwrap();
     v1.add_metadata([("test", "test")]).unwrap();
     assert_eq!(v1.metadata().get("test"), Some("test".into()))
 }
@@ -81,17 +91,18 @@ fn test_metadata_additions() {
 #[test]
 fn test_metadata_updates() {
     let g = Graph::new();
-    let v1 = g.add_node(0, 1, NO_PROPS, None).unwrap();
+    let v1 = g.add_node(0, 1, NO_PROPS, None, None).unwrap();
     v1.add_metadata([("test", "test")]).unwrap();
     v1.update_metadata([("test", "test2")]).unwrap();
     assert_eq!(v1.metadata().get("test"), Some("test2".into()))
 }
 
 #[test]
+#[ignore] // likely we don't want to handle it globally like this anymore, maybe we should introduce an explicit categorical property type?
 fn test_string_deduplication() {
     let g = Graph::new();
     let v1 = g
-        .add_node(0, 1, [("test1", "test"), ("test2", "test")], None)
+        .add_node(0, 1, [("test1", "test"), ("test2", "test")], None, None)
         .unwrap();
     let s1 = v1.properties().get("test1").unwrap_str();
     let s2 = v1.properties().get("test2").unwrap_str();
@@ -104,9 +115,9 @@ fn test_edge_history_and_timestamps() {
     let graph = Graph::new();
 
     // Add nodes
-    graph.add_node(0, 1, NO_PROPS, None).unwrap();
-    graph.add_node(0, 2, NO_PROPS, None).unwrap();
-    graph.add_node(0, 3, NO_PROPS, None).unwrap();
+    graph.add_node(0, 1, NO_PROPS, None, None).unwrap();
+    graph.add_node(0, 2, NO_PROPS, None, None).unwrap();
+    graph.add_node(0, 3, NO_PROPS, None, None).unwrap();
 
     // Add edges at different times
     graph.add_edge(10, 1, 2, NO_PROPS, None).unwrap();
@@ -138,9 +149,9 @@ fn test_edge_timestamps_with_windows() {
     let graph = Graph::new();
 
     // Add nodes
-    graph.add_node(0, 1, NO_PROPS, None).unwrap();
-    graph.add_node(0, 2, NO_PROPS, None).unwrap();
-    graph.add_node(0, 3, NO_PROPS, None).unwrap();
+    graph.add_node(0, 1, NO_PROPS, None, None).unwrap();
+    graph.add_node(0, 2, NO_PROPS, None, None).unwrap();
+    graph.add_node(0, 3, NO_PROPS, None, None).unwrap();
 
     // Add edges at different times
     graph.add_edge(5, 1, 2, NO_PROPS, None).unwrap();
@@ -180,9 +191,9 @@ fn test_edge_timestamps_with_layers() {
     let graph = Graph::new();
 
     // Add nodes
-    graph.add_node(0, 1, NO_PROPS, None).unwrap();
-    graph.add_node(0, 2, NO_PROPS, None).unwrap();
-    graph.add_node(0, 3, NO_PROPS, None).unwrap();
+    graph.add_node(0, 1, NO_PROPS, None, None).unwrap();
+    graph.add_node(0, 2, NO_PROPS, None, None).unwrap();
+    graph.add_node(0, 3, NO_PROPS, None, None).unwrap();
 
     // Add edges on different layers
     graph.add_edge(10, 1, 2, NO_PROPS, Some("layer1")).unwrap();
@@ -190,30 +201,28 @@ fn test_edge_timestamps_with_layers() {
     graph.add_edge(30, 2, 1, NO_PROPS, Some("layer1")).unwrap();
     graph.add_edge(5, 1, 3, NO_PROPS, Some("layer2")).unwrap();
 
-    test_graph(&graph, |graph| {
-        // Test all layers
-        let node1 = graph.node(1).unwrap();
-        let history: Vec<_> = node1.edge_history().map(|(t, _)| t.t()).collect();
-        assert_eq!(history, vec![5, 10, 20, 30]);
-        assert_eq!(node1.earliest_edge_time().unwrap().t(), 5);
-        assert_eq!(node1.latest_edge_time().unwrap().t(), 30);
-
-        // Test layer1 only
-        let layer1_graph = graph.layers(vec!["layer1"]).unwrap();
-        let node1_layer1 = layer1_graph.node(1).unwrap();
-        let history: Vec<_> = node1_layer1.edge_history().map(|(t, _)| t.t()).collect();
-        assert_eq!(history, vec![10, 30]);
-        assert_eq!(node1_layer1.earliest_edge_time().unwrap().t(), 10);
-        assert_eq!(node1_layer1.latest_edge_time().unwrap().t(), 30);
-
-        // Test layer2 only
-        let layer2_graph = graph.layers(vec!["layer2"]).unwrap();
-        let node1_layer2 = layer2_graph.node(1).unwrap();
-        let history: Vec<_> = node1_layer2.edge_history().map(|(t, _)| t.t()).collect();
-        assert_eq!(history, vec![5, 20]);
-        assert_eq!(node1_layer2.earliest_edge_time().unwrap().t(), 5);
-        assert_eq!(node1_layer2.latest_edge_time().unwrap().t(), 20);
-    });
+    // Test all layers
+    let node1 = graph.node(1).unwrap();
+    let history: Vec<_> = node1.edge_history().map(|(t, _)| t.t()).collect();
+    assert_eq!(history, vec![5, 10, 20, 30]);
+    assert_eq!(node1.earliest_edge_time().unwrap().t(), 5);
+    assert_eq!(node1.latest_edge_time().unwrap().t(), 30);
+
+    // Test layer1 only
+    let layer1_graph = graph.layers(vec!["layer1"]).unwrap();
+    let node1_layer1 = layer1_graph.node(1).unwrap();
+    let history: Vec<_> = node1_layer1.edge_history().map(|(t, _)| t.t()).collect();
+    assert_eq!(history, vec![10, 30]);
+    assert_eq!(node1_layer1.earliest_edge_time().unwrap().t(), 10);
+    assert_eq!(node1_layer1.latest_edge_time().unwrap().t(), 30);
+
+    // Test layer2 only
+    let layer2_graph = graph.layers(vec!["layer2"]).unwrap();
+    let node1_layer2 = layer2_graph.node(1).unwrap();
+    let history: Vec<_> = node1_layer2.edge_history().map(|(t, _)| t.t()).collect();
+    assert_eq!(history, vec![5, 20]);
+    assert_eq!(node1_layer2.earliest_edge_time().unwrap().t(), 5);
+    assert_eq!(node1_layer2.latest_edge_time().unwrap().t(), 20);
 }
 
 #[test]
@@ -221,10 +230,10 @@ fn test_edge_timestamps_overlapping_windows_and_layers() {
     let graph = Graph::new();
 
     // Add nodes
-    graph.add_node(0, 1, NO_PROPS, None).unwrap();
-    graph.add_node(0, 2, NO_PROPS, None).unwrap();
-    graph.add_node(0, 3, NO_PROPS, None).unwrap();
-    graph.add_node(0, 4, NO_PROPS, None).unwrap();
+    graph.add_node(0, 1, NO_PROPS, None, None).unwrap();
+    graph.add_node(0, 2, NO_PROPS, None, None).unwrap();
+    graph.add_node(0, 3, NO_PROPS, None, None).unwrap();
+    graph.add_node(0, 4, NO_PROPS, None, None).unwrap();
 
     // Add edges with overlapping time ranges across multiple layers
     graph.add_edge(5, 1, 2, NO_PROPS, Some("layer1")).unwrap();
@@ -277,7 +286,7 @@ fn test_edge_timestamps_no_edges() {
     let graph = Graph::new();
 
     // Add a node but no edges
-    graph.add_node(10, 1, NO_PROPS, None).unwrap();
+    graph.add_node(10, 1, NO_PROPS, None, None).unwrap();
 
     test_graph(&graph, |graph| {
         let node1 = graph.node(1).unwrap();
@@ -289,3 +298,137 @@ fn test_edge_timestamps_no_edges() {
         assert_eq!(node1.latest_edge_time(), None);
     });
 }
+
+#[test]
+fn test_node_layers() {
+    let graph = Graph::new();
+    graph
+        .add_node(0, 1, [("a", "test")], None, Some("fire_nation"))
+        .unwrap();
+    graph
+        .add_node(0, 2, NO_PROPS, None, Some("fire_nation"))
+        .unwrap();
+    graph
+        .add_node(0, 3, [("b", 3)], None, Some("air_nomads"))
+        .unwrap();
+
+    let filter_expr = NodeFilter.layer("fire_nation").is_active();
+    let ids = graph
+        .filter(filter_expr)
+        .unwrap()
+        .nodes()
+        .iter()
+        .map(|n| n.name())
+        .collect::<Vec<_>>();
+
+    assert_eq!(ids, vec!["1", "2"]);
+}
+
+/// Nodes added without a layer (`layer=None`) go into STATIC_GRAPH_LAYER_ID and must be
+/// visible as active in every layer-restricted view.
+#[test]
+fn test_unlayered_node_visible_in_all_layer_views() {
+    let graph = Graph::new();
+    // Node 1 added without a layer — should appear in any layer view
+    graph.add_node(0, 1, NO_PROPS, None, None).unwrap();
+    // Node 2 added with "fire_nation" — should only appear in that view
+    graph
+        .add_node(0, 2, NO_PROPS, None, Some("fire_nation"))
+        .unwrap();
+
+    let fire_view = graph
+        .filter(NodeFilter.layer("fire_nation").is_active())
+        .unwrap();
+    let mut ids: Vec<_> = fire_view.nodes().iter().map(|n| n.name()).collect();
+    ids.sort();
+    // Both node 1 (unlayered/static) and node 2 (fire_nation) should be visible
+    assert_eq!(
+        ids,
+        vec!["1", "2"],
+        "unlayered node must appear in fire_nation view"
+    );
+}
+
+/// A node added with layer A must NOT appear in a filter restricted to layer B.
+#[test]
+fn test_layered_node_not_visible_in_other_layer_view() {
+    let graph = Graph::new();
+    graph
+        .add_node(0, 1, NO_PROPS, None, Some("fire_nation"))
+        .unwrap();
+    graph
+        .add_node(0, 2, NO_PROPS, None, Some("air_nomads"))
+        .unwrap();
+
+    let fire_view = graph
+        .filter(NodeFilter.layer("fire_nation").is_active())
+        .unwrap();
+    let ids: Vec<_> = fire_view.nodes().iter().map(|n| n.name()).collect();
+    assert_eq!(
+        ids,
+        vec!["1"],
+        "air_nomads node must not appear in fire_nation view"
+    );
+}
+
+/// Nodes added without a layer should appear in a windowed + layer-filtered view
+/// as long as they have activity within the window.
+#[test]
+fn test_unlayered_node_visible_in_windowed_layer_view() {
+    let graph = Graph::new();
+    graph.add_node(5, 1, NO_PROPS, None, None).unwrap(); // unlayered, t=5
+    graph
+        .add_node(5, 2, NO_PROPS, None, Some("fire_nation"))
+        .unwrap(); // layered, t=5
+    graph
+        .add_node(5, 3, NO_PROPS, None, Some("air_nomads"))
+        .unwrap();
+
+    // Window [0, 10) covers t=5; filter to fire_nation
+    let view = graph.window(0, 10);
+    let fire_view = view
+        .filter(NodeFilter.layer("fire_nation").is_active())
+        .unwrap();
+    let mut ids: Vec<_> = fire_view.nodes().iter().map(|n| n.name()).collect();
+    ids.sort();
+    assert_eq!(
+        ids,
+        vec!["1", "2"],
+        "unlayered node at t=5 must appear in windowed fire_nation view"
+    );
+
+    // Window [10, 20) does NOT cover t=5, so no nodes should be active
+    let view_out = graph.window(10, 20);
+    let fire_view_out = view_out
+        .filter(NodeFilter.layer("fire_nation").is_active())
+        .unwrap();
+    assert_eq!(
+        fire_view_out.count_nodes(),
+        0,
+        "no nodes should be active outside the window"
+    );
+}
+
+/// Node history (timestamps) should be scoped to the requested layer, not bleed
+/// across layers.
+#[test]
+fn test_node_history_scoped_to_layer() {
+    let graph = Graph::new();
+    // Node 1 exists in fire_nation at t=1 and air_nomads at t=2
+    graph
+        .add_node(1, 1, NO_PROPS, None, Some("fire_nation"))
+        .unwrap();
+    graph
+        .add_node(2, 1, NO_PROPS, None, Some("air_nomads"))
+        .unwrap();
+
+    let fire_layer = graph.layers("fire_nation").unwrap();
+    let node = fire_layer.node(1).unwrap();
+    let history: Vec<i64> = node.history().t().collect();
+    // Only the fire_nation timestamp should be visible
+    assert_eq!(
+        history,
+        vec![1],
+        "history must not include timestamps from other layers"
+    );
+}
diff --git a/raphtory/tests/proto_test.rs b/raphtory/tests/proto_test.rs
index 41e4f7c18c..730d69b42e 100644
--- a/raphtory/tests/proto_test.rs
+++ b/raphtory/tests/proto_test.rs
@@ -4,41 +4,52 @@ mod proto_test {
     use chrono::{DateTime, NaiveDateTime};
     use itertools::Itertools;
     use proptest::proptest;
+    use prost::Message;
     use raphtory::{
         db::{
             api::{mutation::DeletionOps, properties::internal::InternalMetadataOps},
             graph::{graph::assert_graph_equal, views::deletion_graph::PersistentGraph},
         },
         prelude::*,
-        serialise::{metadata::assert_metadata_correct, GraphFolder, InternalStableDecode},
+        serialise::{
+            metadata::assert_metadata_correct,
+            proto::{proto_generated::GraphType, ProtoDecoder, ProtoEncoder},
+            GraphFolder, ProtoGraph,
+        },
     };
     use raphtory_api::core::{
         entities::properties::{meta::PropMapper, prop::PropType},
         storage::arc_str::ArcStr,
     };
+    use raphtory_core::{
+        entities::{GidRef, EID, VID},
+        storage::timeindex::EventTime,
+    };
     use raphtory_storage::core_ops::CoreGraphOps;
-    use std::{collections::HashMap, path::PathBuf, sync::Arc};
+    use std::{collections::HashMap, io::Cursor, iter, path::PathBuf, sync::Arc};
     use tempfile::TempDir;
 
-    #[cfg(feature = "arrow")]
     use arrow::array::types::{Int32Type, UInt8Type};
     use raphtory::test_utils::{build_edge_list, build_graph_from_edge_list};
+    use raphtory_api::core::entities::LayerId;
 
     #[test]
     fn prev_proto_str() {
         let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
             .parent()
-            .map(|p| p.join("raphtory/resources/test/old_proto/str"))
+            .map(|p| p.join("raphtory/resources/test/old_proto/str/graph"))
             .unwrap();
 
-        let graph = Graph::decode(path).unwrap();
-
+        let bytes = std::fs::read(path).unwrap();
+        let proto_graph = ProtoGraph::decode(Cursor::new(bytes)).unwrap();
+        let graph = Graph::decode_from_proto(&proto_graph).unwrap();
         let nodes_props = graph
             .nodes()
             .properties()
             .into_iter()
             .flat_map(|(_, props)| props.into_iter())
             .collect::<Vec<_>>();
+
         assert_eq!(
             nodes_props,
             vec![("a".into(), Some("a".into())), ("a".into(), None)]
@@ -54,15 +65,17 @@ mod proto_test {
         //     .collect::<Vec<_>>();
         // assert_eq!(nodes_metadata, vec![("z".into(), Some("a".into())),]);
     }
+
     #[test]
     fn can_read_previous_proto() {
         let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
             .parent()
-            .map(|p| p.join("raphtory/resources/test/old_proto/all_props"))
+            .map(|p| p.join("raphtory/resources/test/old_proto/all_props/graph"))
             .unwrap();
 
-        let graph = Graph::decode(path).unwrap();
-
+        let bytes = std::fs::read(path).unwrap();
+        let proto_graph = ProtoGraph::decode(Cursor::new(bytes)).unwrap();
+        let graph = Graph::decode_from_proto(&proto_graph).unwrap();
         let actual: HashMap<_, _> = graph
             .node_meta()
             .get_all_property_names(false)
@@ -250,7 +263,7 @@ mod proto_test {
         let pm = graph.edge_meta().temporal_prop_mapper();
         check_prop_mapper(pm);
 
-        let pm = graph.graph_meta().temporal_mapper();
+        let pm = graph.graph_props_meta().temporal_prop_mapper();
         check_prop_mapper(pm);
 
         let mut vec1 = actual.keys().collect::<Vec<_>>();
@@ -265,509 +278,52 @@ mod proto_test {
     }
 
     #[test]
-    fn node_no_props() {
-        let tempdir = TempDir::new().unwrap();
-        let temp_file = tempdir.path().join("graph");
-        let g1 = Graph::new();
-        g1.add_node(1, "Alice", NO_PROPS, None).unwrap();
-        g1.encode(&temp_file).unwrap();
-        let g2 = Graph::decode(&temp_file).unwrap();
-        assert_graph_equal(&g1, &g2);
-    }
-
-    #[test]
-    fn node_with_props() {
-        let tempdir = TempDir::new().unwrap();
-        let temp_file = tempdir.path().join("graph");
-        let g1 = Graph::new();
-        g1.add_node(1, "Alice", NO_PROPS, None).unwrap();
-        g1.add_node(2, "Bob", [("age", Prop::U32(47))], None)
-            .unwrap();
-        g1.encode(&temp_file).unwrap();
-        let g2 = Graph::decode(&temp_file).unwrap();
-        assert_graph_equal(&g1, &g2);
-    }
-
-    #[cfg(feature = "search")]
-    #[test]
-    fn test_node_name() {
-        use raphtory::db::api::view::MaterializedGraph;
-
-        let g = Graph::new();
-        g.add_edge(1, "ben", "hamza", NO_PROPS, None).unwrap();
-        g.add_edge(2, "haaroon", "hamza", NO_PROPS, None).unwrap();
-        g.add_edge(3, "ben", "haaroon", NO_PROPS, None).unwrap();
-        let temp_file = TempDir::new().unwrap();
-
-        g.encode(&temp_file).unwrap();
-        let g2 = MaterializedGraph::load_cached(&temp_file).unwrap();
-        assert_eq!(g2.nodes().name().collect_vec(), ["ben", "hamza", "haaroon"]);
-        let node_names: Vec<_> = g2.nodes().iter().map(|n| n.name()).collect();
-        assert_eq!(node_names, ["ben", "hamza", "haaroon"]);
-        let g2_m = g2.materialize().unwrap();
-        assert_eq!(
-            g2_m.nodes().name().collect_vec(),
-            ["ben", "hamza", "haaroon"]
+    fn manually_test_append() {
+        let mut graph1 = ProtoGraph::default();
+
+        graph1.set_graph_type(GraphType::Event);
+        graph1.new_node(GidRef::Str("1"), VID(0), 0);
+        graph1.new_node(GidRef::Str("2"), VID(1), 0);
+        graph1.new_edge(VID(0), VID(1), EID(0));
+        graph1.update_edge_tprops(
+            EID(0),
+            EventTime::start(1),
+            LayerId(0),
+            iter::empty::<(usize, Prop)>(),
         );
-        let g3 = g.materialize().unwrap();
-        assert_eq!(g3.nodes().name().collect_vec(), ["ben", "hamza", "haaroon"]);
-        let node_names: Vec<_> = g3.nodes().iter().map(|n| n.name()).collect();
-        assert_eq!(node_names, ["ben", "hamza", "haaroon"]);
 
-        let temp_file = TempDir::new().unwrap();
-        g3.encode(&temp_file).unwrap();
-        let g4 = MaterializedGraph::decode(&temp_file).unwrap();
-        assert_eq!(g4.nodes().name().collect_vec(), ["ben", "hamza", "haaroon"]);
-        let node_names: Vec<_> = g4.nodes().iter().map(|n| n.name()).collect();
-        assert_eq!(node_names, ["ben", "hamza", "haaroon"]);
-    }
+        let mut bytes1 = graph1.encode_to_vec();
+        let mut graph2 = ProtoGraph::default();
 
-    #[test]
-    fn node_with_metadata() {
-        let tempdir = TempDir::new().unwrap();
-        let temp_file = tempdir.path().join("graph");
-        let g1 = Graph::new();
-        g1.add_node(1, "Alice", NO_PROPS, None).unwrap();
-        let n1 = g1
-            .add_node(2, "Bob", [("age", Prop::U32(47))], None)
-            .unwrap();
-
-        n1.update_metadata([("name", Prop::Str("Bob".into()))])
-            .expect("Failed to update metadata");
-
-        g1.encode(&temp_file).unwrap();
-        let g2 = Graph::decode(&temp_file).unwrap();
-        assert_graph_equal(&g1, &g2);
-    }
-
-    #[test]
-    fn edge_no_props() {
-        let tempdir = TempDir::new().unwrap();
-        let temp_file = tempdir.path().join("graph");
-        let g1 = Graph::new();
-        g1.add_node(1, "Alice", NO_PROPS, None).unwrap();
-        g1.add_node(2, "Bob", NO_PROPS, None).unwrap();
-        g1.add_edge(3, "Alice", "Bob", NO_PROPS, None).unwrap();
-        g1.encode(&temp_file).unwrap();
-        let g2 = Graph::decode(&temp_file).unwrap();
-        assert_graph_equal(&g1, &g2);
-    }
-
-    #[test]
-    fn edge_no_props_delete() {
-        let tempdir = TempDir::new().unwrap();
-        let temp_file = tempdir.path().join("graph");
-        let g1 = Graph::new().persistent_graph();
-        g1.add_edge(3, "Alice", "Bob", NO_PROPS, None).unwrap();
-        g1.delete_edge(19, "Alice", "Bob", None).unwrap();
-        g1.encode(&temp_file).unwrap();
-        let g2 = PersistentGraph::decode(&temp_file).unwrap();
-        assert_graph_equal(&g1, &g2);
-
-        let edge = g2.edge("Alice", "Bob").expect("Failed to get edge");
-        let deletions = edge.deletions().collect();
-        assert_eq!(deletions, vec![19]);
-    }
+        graph2.new_node(GidRef::Str("3"), VID(2), 0);
+        graph2.new_edge(VID(0), VID(2), EID(1));
+        graph2.update_edge_tprops(
+            EID(1),
+            EventTime::start(2),
+            LayerId(0),
+            iter::empty::<(usize, Prop)>(),
+        );
+        bytes1.extend(graph2.encode_to_vec());
 
-    #[test]
-    fn edge_t_props() {
-        let tempdir = TempDir::new().unwrap();
-        let temp_file = tempdir.path().join("graph");
-        let g1 = Graph::new();
-        g1.add_node(1, "Alice", NO_PROPS, None).unwrap();
-        g1.add_node(2, "Bob", NO_PROPS, None).unwrap();
-        g1.add_edge(3, "Alice", "Bob", [("kind", "friends")], None)
-            .unwrap();
+        let buf = bytes1.as_slice();
+        let proto_graph = ProtoGraph::decode(buf).unwrap();
+        let graph = Graph::decode_from_proto(&proto_graph).unwrap();
 
-        #[cfg(feature = "arrow")]
-        g1.add_edge(
-            3,
-            "Alice",
-            "Bob",
-            [("image", Prop::from_arr::<Int32Type>(vec![3i32, 5]))],
-            None,
+        assert_eq!(graph.nodes().name().collect_vec(), ["1", "2", "3"]);
+        assert_eq!(
+            graph.edges().id().collect_vec(),
+            [
+                (GID::Str("1".to_string()), GID::Str("2".to_string())),
+                (GID::Str("1".to_string()), GID::Str("3".to_string()))
+            ]
         )
-        .unwrap();
-
-        g1.encode(&temp_file).unwrap();
-        let g2 = Graph::decode(&temp_file).unwrap();
-        assert_graph_equal(&g1, &g2);
-    }
-
-    #[test]
-    fn edge_metadata() {
-        let tempdir = TempDir::new().unwrap();
-        let temp_file = tempdir.path().join("graph");
-        let g1 = Graph::new();
-        let e1 = g1.add_edge(3, "Alice", "Bob", NO_PROPS, None).unwrap();
-        e1.update_metadata([("friends", true)], None)
-            .expect("Failed to update metadata");
-        g1.encode(&temp_file).unwrap();
-        let g2 = Graph::decode(&temp_file).unwrap();
-        assert_graph_equal(&g1, &g2);
-    }
-
-    #[test]
-    fn edge_layers() {
-        let tempdir = TempDir::new().unwrap();
-        let temp_file = tempdir.path().join("graph");
-        let g1 = Graph::new();
-        g1.add_edge(7, "Alice", "Bob", NO_PROPS, Some("one"))
-            .unwrap();
-        g1.add_edge(7, "Bob", "Charlie", [("friends", false)], Some("two"))
-            .unwrap();
-        g1.encode(&temp_file).unwrap();
-        let g2 = Graph::decode(&temp_file).unwrap();
-        assert_graph_equal(&g1, &g2);
-    }
-
-    #[test]
-    fn test_all_the_t_props_on_node() {
-        let mut props = vec![];
-        write_props_to_vec(&mut props);
-
-        let tempdir = TempDir::new().unwrap();
-        let temp_file = tempdir.path().join("graph");
-        let g1 = Graph::new();
-        g1.add_node(1, "Alice", props.clone(), None).unwrap();
-        g1.encode(&temp_file).unwrap();
-        let g2 = Graph::decode(&temp_file).unwrap();
-        assert_graph_equal(&g1, &g2);
-
-        let node = g2.node("Alice").expect("Failed to get node");
-
-        assert!(props.into_iter().all(|(name, expected)| {
-            node.properties()
-                .temporal()
-                .get(name)
-                .filter(|prop_view| {
-                    let (t, prop) = prop_view.iter().next().expect("Failed to get prop");
-                    prop == expected && t == 1
-                })
-                .is_some()
-        }))
-    }
-
-    #[test]
-    fn test_all_the_t_props_on_edge() {
-        let mut props = vec![];
-        write_props_to_vec(&mut props);
-
-        let tempdir = TempDir::new().unwrap();
-        let temp_file = tempdir.path().join("graph");
-        let g1 = Graph::new();
-        g1.add_edge(1, "Alice", "Bob", props.clone(), None).unwrap();
-        g1.encode(&temp_file).unwrap();
-        let g2 = Graph::decode(&temp_file).unwrap();
-        assert_graph_equal(&g1, &g2);
-
-        let edge = g2.edge("Alice", "Bob").expect("Failed to get edge");
-
-        assert!(props.into_iter().all(|(name, expected)| {
-            edge.properties()
-                .temporal()
-                .get(name)
-                .filter(|prop_view| {
-                    let (t, prop) = prop_view.iter().next().expect("Failed to get prop");
-                    prop == expected && t == 1
-                })
-                .is_some()
-        }))
-    }
-
-    #[test]
-    fn test_all_the_metadata_on_edge() {
-        let mut props = vec![];
-        write_props_to_vec(&mut props);
-
-        let tempdir = TempDir::new().unwrap();
-        let temp_file = tempdir.path().join("graph");
-        let g1 = Graph::new();
-        let e = g1.add_edge(1, "Alice", "Bob", NO_PROPS, Some("a")).unwrap();
-        e.update_metadata(props.clone(), Some("a"))
-            .expect("Failed to update metadata");
-        g1.encode(&temp_file).unwrap();
-        let g2 = Graph::decode(&temp_file).unwrap();
-        assert_graph_equal(&g1, &g2);
-
-        let edge = g2
-            .edge("Alice", "Bob")
-            .expect("Failed to get edge")
-            .layers("a")
-            .unwrap();
-
-        for (new, old) in edge.metadata().iter_filtered().zip(props.iter()) {
-            assert_eq!(new.0, old.0);
-            assert_eq!(new.1, old.1);
-        }
-    }
-
-    #[test]
-    fn test_all_the_metadata_on_node() {
-        let mut props = vec![];
-        write_props_to_vec(&mut props);
-
-        let tempdir = TempDir::new().unwrap();
-        let temp_file = tempdir.path().join("graph");
-        let g1 = Graph::new();
-        let n = g1.add_node(1, "Alice", NO_PROPS, None).unwrap();
-        n.update_metadata(props.clone())
-            .expect("Failed to update metadata");
-        g1.encode(&temp_file).unwrap();
-        let g2 = Graph::decode(&temp_file).unwrap();
-        assert_graph_equal(&g1, &g2);
-
-        let node = g2.node("Alice").expect("Failed to get node");
-
-        assert!(props.into_iter().all(|(name, expected)| {
-            node.metadata()
-                .get(name)
-                .filter(|prop| prop == &expected)
-                .is_some()
-        }))
-    }
-
-    #[test]
-    fn graph_metadata() {
-        let mut props = vec![];
-        write_props_to_vec(&mut props);
-
-        let g1 = Graph::new();
-        g1.add_metadata(props.clone())
-            .expect("Failed to add metadata");
-
-        let tempdir = TempDir::new().unwrap();
-        let temp_file = tempdir.path().join("graph");
-        g1.encode(&temp_file).unwrap();
-        let g2 = Graph::decode(&temp_file).unwrap();
-        assert_graph_equal(&g1, &g2);
-
-        props.into_iter().for_each(|(name, prop)| {
-            let id = g2.get_metadata_id(name).expect("Failed to get prop id");
-            assert_eq!(prop, g2.get_metadata(id).expect("Failed to get prop"));
-        });
-    }
-
-    #[test]
-    fn graph_temp_properties() {
-        let mut props = vec![];
-        write_props_to_vec(&mut props);
-
-        let g1 = Graph::new();
-        for t in 0..props.len() {
-            g1.add_properties(t as i64, props[t..t + 1].to_vec())
-                .expect("Failed to add metadata");
-        }
-
-        let tempdir = TempDir::new().unwrap();
-        let temp_file = tempdir.path().join("graph");
-        g1.encode(&temp_file).unwrap();
-        let g2 = Graph::decode(&temp_file).unwrap();
-        assert_graph_equal(&g1, &g2);
-
-        props
-            .into_iter()
-            .enumerate()
-            .for_each(|(expected_t, (name, expected))| {
-                for (t, prop) in g2
-                    .properties()
-                    .temporal()
-                    .get(name)
-                    .expect("Failed to get prop view")
-                {
-                    assert_eq!(prop, expected);
-                    assert_eq!(t, expected_t as i64);
-                }
-            });
-    }
-
-    #[test]
-    fn test_string_interning() {
-        let g = Graph::new();
-        let n = g.add_node(0, 1, [("test", "test")], None).unwrap();
-
-        n.add_updates(1, [("test", "test")]).unwrap();
-        n.add_updates(2, [("test", "test")]).unwrap();
-
-        let values = n
-            .properties()
-            .temporal()
-            .get("test")
-            .unwrap()
-            .values()
-            .map(|v| v.unwrap_str())
-            .collect_vec();
-        assert_eq!(values, ["test", "test", "test"]);
-        for w in values.windows(2) {
-            assert_eq!(w[0].as_ptr(), w[1].as_ptr());
-        }
-
-        let proto = g.encode_to_proto();
-        let g2 = Graph::decode_from_proto(&proto).unwrap();
-        let node_view = g2.node(1).unwrap();
-
-        let values = node_view
-            .properties()
-            .temporal()
-            .get("test")
-            .unwrap()
-            .values()
-            .map(|v| v.unwrap_str())
-            .collect_vec();
-        assert_eq!(values, ["test", "test", "test"]);
-        for w in values.windows(2) {
-            assert_eq!(w[0].as_ptr(), w[1].as_ptr());
-        }
-    }
-
-    #[test]
-    fn test_incremental_writing_on_graph() {
-        let g = Graph::new();
-        let mut props = vec![];
-        write_props_to_vec(&mut props);
-        let temp_cache_file = tempfile::tempdir().unwrap();
-        let folder = GraphFolder::from(&temp_cache_file);
-
-        g.cache(&temp_cache_file).unwrap();
-
-        assert_metadata_correct(&folder, &g);
-
-        for t in 0..props.len() {
-            g.add_properties(t as i64, props[t..t + 1].to_vec())
-                .expect("Failed to add metadata");
-        }
-        g.write_updates().unwrap();
-
-        g.add_metadata(props.clone())
-            .expect("Failed to add metadata");
-        g.write_updates().unwrap();
-
-        let n = g.add_node(1, "Alice", NO_PROPS, None).unwrap();
-        n.update_metadata(props.clone())
-            .expect("Failed to update metadata");
-        g.write_updates().unwrap();
-
-        let e = g.add_edge(1, "Alice", "Bob", NO_PROPS, Some("a")).unwrap();
-        e.update_metadata(props.clone(), Some("a"))
-            .expect("Failed to update metadata");
-        g.write_updates().unwrap();
-
-        assert_metadata_correct(&folder, &g);
-
-        g.add_edge(2, "Alice", "Bob", props.clone(), None).unwrap();
-        g.add_node(1, "Charlie", props.clone(), None).unwrap();
-        g.write_updates().unwrap();
-
-        g.add_edge(7, "Alice", "Bob", NO_PROPS, Some("one"))
-            .unwrap();
-        g.add_edge(7, "Bob", "Charlie", [("friends", false)], Some("two"))
-            .unwrap();
-        g.write_updates().unwrap();
-        let g2 = Graph::decode(&temp_cache_file).unwrap();
-        assert_graph_equal(&g, &g2);
-
-        assert_metadata_correct(&folder, &g);
     }
 
+    // we rely on this to make sure writing no updates does not actually write anything to file
     #[test]
-    fn test_incremental_writing_on_persistent_graph() {
-        let g = PersistentGraph::new();
-        let mut props = vec![];
-        write_props_to_vec(&mut props);
-        let temp_cache_file = tempfile::tempdir().unwrap();
-        let folder = GraphFolder::from(&temp_cache_file);
-
-        g.cache(&temp_cache_file).unwrap();
-
-        for t in 0..props.len() {
-            g.add_properties(t as i64, props[t..t + 1].to_vec())
-                .expect("Failed to add metadata");
-        }
-        g.write_updates().unwrap();
-
-        g.add_metadata(props.clone())
-            .expect("Failed to add metadata");
-        g.write_updates().unwrap();
-
-        let n = g.add_node(1, "Alice", NO_PROPS, None).unwrap();
-        n.update_metadata(props.clone())
-            .expect("Failed to update metadata");
-        g.write_updates().unwrap();
-
-        let e = g.add_edge(1, "Alice", "Bob", NO_PROPS, Some("a")).unwrap();
-        e.update_metadata(props.clone(), Some("a"))
-            .expect("Failed to update metadata");
-        g.write_updates().unwrap();
-
-        assert_metadata_correct(&folder, &g);
-
-        g.add_edge(2, "Alice", "Bob", props.clone(), None).unwrap();
-        g.add_node(1, "Charlie", props.clone(), None).unwrap();
-        g.write_updates().unwrap();
-
-        g.add_edge(7, "Alice", "Bob", NO_PROPS, Some("one"))
-            .unwrap();
-        g.add_edge(7, "Bob", "Charlie", [("friends", false)], Some("two"))
-            .unwrap();
-        g.write_updates().unwrap();
-
-        let g2 = PersistentGraph::decode(&temp_cache_file).unwrap();
-
-        assert_graph_equal(&g, &g2);
-
-        assert_metadata_correct(&folder, &g);
-    }
-
-    #[test]
-    fn encode_decode_prop_test() {
-        proptest!(|(edges in build_edge_list(100, 100))| {
-            let g = build_graph_from_edge_list(&edges);
-            let bytes = g.encode_to_vec();
-            let g2 = Graph::decode_from_bytes(&bytes).unwrap();
-            assert_graph_equal(&g, &g2);
-        })
-    }
-
-    fn write_props_to_vec(props: &mut Vec<(&str, Prop)>) {
-        props.push(("name", Prop::Str("Alice".into())));
-        props.push(("age", Prop::U32(47)));
-        props.push(("score", Prop::I32(27)));
-        props.push(("is_adult", Prop::Bool(true)));
-        props.push(("height", Prop::F32(1.75)));
-        props.push(("weight", Prop::F64(75.5)));
-        props.push((
-            "children",
-            Prop::List(Arc::new(vec![
-                Prop::Str("Bob".into()),
-                Prop::Str("Charlie".into()),
-            ])),
-        ));
-        props.push((
-            "properties",
-            Prop::map(props.iter().map(|(k, v)| (ArcStr::from(*k), v.clone()))),
-        ));
-        let fmt = "%Y-%m-%d %H:%M:%S";
-        props.push((
-            "time",
-            Prop::NDTime(
-                NaiveDateTime::parse_from_str("+10000-09-09 01:46:39", fmt)
-                    .expect("Failed to parse time"),
-            ),
-        ));
-
-        props.push((
-            "dtime",
-            Prop::DTime(
-                DateTime::parse_from_rfc3339("2021-09-09T01:46:39Z")
-                    .unwrap()
-                    .into(),
-            ),
-        ));
-
-        #[cfg(feature = "arrow")]
-        props.push((
-            "array",
-            Prop::from_arr::<UInt8Type>(vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]),
-        ));
+    fn empty_proto_is_empty_bytes() {
+        let proto = ProtoGraph::default();
+        let bytes = proto.encode_to_vec();
+        assert!(bytes.is_empty())
     }
 }
diff --git a/raphtory/tests/serialise_test.rs b/raphtory/tests/serialise_test.rs
new file mode 100644
index 0000000000..13a4faea94
--- /dev/null
+++ b/raphtory/tests/serialise_test.rs
@@ -0,0 +1,479 @@
+#[cfg(test)]
+#[cfg(feature = "proto")]
+mod serialise_test {
+
+    use arrow::{array::types::Int32Type, datatypes::UInt8Type};
+    use chrono::{DateTime, NaiveDateTime};
+    use itertools::Itertools;
+    #[cfg(feature = "proto")]
+    use proptest::proptest;
+    use raphtory::{
+        db::{
+            api::properties::internal::InternalMetadataOps,
+            graph::{graph::assert_graph_equal, views::deletion_graph::PersistentGraph},
+        },
+        prelude::*,
+        serialise::{metadata::assert_metadata_correct, GraphFolder},
+        test_utils::{build_edge_list, build_graph_from_edge_list},
+    };
+    use raphtory_api::core::{
+        entities::properties::{meta::PropMapper, prop::PropType},
+        storage::arc_str::ArcStr,
+    };
+    use raphtory_core::{entities::GidRef, storage::timeindex::EventTime};
+    use raphtory_storage::core_ops::CoreGraphOps;
+    use std::{collections::HashMap, path::PathBuf, sync::Arc};
+    use storage::Config;
+    use tempfile::TempDir;
+
+    #[test]
+    fn node_no_props() {
+        let tempdir = TempDir::new().unwrap();
+        let temp_file = tempdir.path().join("graph");
+        let g1 = Graph::new();
+        g1.add_node(1, "Alice", NO_PROPS, None, None).unwrap();
+        g1.encode(&temp_file).unwrap();
+        let g2 = Graph::decode(&temp_file).unwrap();
+        assert_graph_equal(&g1, &g2);
+    }
+
+    #[test]
+    fn node_with_props() {
+        let tempdir = TempDir::new().unwrap();
+        let temp_file = tempdir.path().join("graph");
+        let g1 = Graph::new();
+        g1.add_node(1, "Alice", NO_PROPS, None, None).unwrap();
+        g1.add_node(2, "Bob", [("age", Prop::U32(47))], None, None)
+            .unwrap();
+        g1.encode(&temp_file).unwrap();
+        let g2 = Graph::decode(&temp_file).unwrap();
+        assert_graph_equal(&g1, &g2);
+    }
+
+    #[cfg(feature = "search")]
+    #[test]
+    fn test_node_name() {
+        use raphtory::db::api::view::MaterializedGraph;
+
+        let g = Graph::new();
+        g.add_edge(1, "ben", "hamza", NO_PROPS, None).unwrap();
+        g.add_edge(2, "haaroon", "hamza", NO_PROPS, None).unwrap();
+        g.add_edge(3, "ben", "haaroon", NO_PROPS, None).unwrap();
+        let temp_file = TempDir::new().unwrap();
+
+        g.encode(&temp_file).unwrap();
+        let g2 = MaterializedGraph::decode(&temp_file).unwrap();
+        assert_eq!(g2.nodes().name().collect_vec(), ["ben", "hamza", "haaroon"]);
+        let node_names: Vec<_> = g2.nodes().iter().map(|n| n.name()).collect();
+        assert_eq!(node_names, ["ben", "hamza", "haaroon"]);
+        let g2_m = g2.materialize().unwrap();
+        assert_eq!(
+            g2_m.nodes().name().collect_vec(),
+            ["ben", "hamza", "haaroon"]
+        );
+        let g3 = g.materialize().unwrap();
+        assert_eq!(g3.nodes().name().collect_vec(), ["ben", "hamza", "haaroon"]);
+        let node_names: Vec<_> = g3.nodes().iter().map(|n| n.name()).collect();
+        assert_eq!(node_names, ["ben", "hamza", "haaroon"]);
+
+        let temp_file = TempDir::new().unwrap();
+        g3.encode(&temp_file).unwrap();
+        let g4 = MaterializedGraph::decode(&temp_file).unwrap();
+        assert_eq!(g4.nodes().name().collect_vec(), ["ben", "hamza", "haaroon"]);
+        let node_names: Vec<_> = g4.nodes().iter().map(|n| n.name()).collect();
+        assert_eq!(node_names, ["ben", "hamza", "haaroon"]);
+    }
+
+    #[test]
+    fn node_with_metadata() {
+        let tempdir = TempDir::new().unwrap();
+        let temp_file = tempdir.path().join("graph");
+        let g1 = Graph::new();
+        g1.add_node(1, "Alice", NO_PROPS, None, None).unwrap();
+        let n1 = g1
+            .add_node(2, "Bob", [("age", Prop::U32(47))], None, None)
+            .unwrap();
+
+        n1.update_metadata([("name", Prop::Str("Bob".into()))])
+            .expect("Failed to update metadata");
+
+        g1.encode(&temp_file).unwrap();
+        let g2 = Graph::decode(&temp_file).unwrap();
+        assert_graph_equal(&g1, &g2);
+    }
+
+    #[test]
+    fn edge_no_props() {
+        let tempdir = TempDir::new().unwrap();
+        let temp_file = tempdir.path().join("graph");
+        let g1 = Graph::new();
+        g1.add_node(1, "Alice", NO_PROPS, None, None).unwrap();
+        g1.add_node(2, "Bob", NO_PROPS, None, None).unwrap();
+        g1.add_edge(3, "Alice", "Bob", NO_PROPS, None).unwrap();
+        g1.encode(&temp_file).unwrap();
+        let g2 = Graph::decode(&temp_file).unwrap();
+        assert_graph_equal(&g1, &g2);
+    }
+
+    #[test]
+    fn edge_no_props_delete() {
+        let tempdir = TempDir::new().unwrap();
+        let temp_file = tempdir.path().join("graph");
+        let g1 = Graph::new().persistent_graph();
+        g1.add_edge(3, "Alice", "Bob", NO_PROPS, None).unwrap();
+        g1.delete_edge(19, "Alice", "Bob", None).unwrap();
+        g1.encode(&temp_file).unwrap();
+        let g2 = PersistentGraph::decode(&temp_file).unwrap();
+        assert_graph_equal(&g1, &g2);
+
+        let edge = g2.edge("Alice", "Bob").expect("Failed to get edge");
+        let deletions = edge.deletions().t().iter().collect::<Vec<_>>();
+        assert_eq!(deletions, vec![19]);
+    }
+
+    #[test]
+    fn edge_t_props() {
+        let tempdir = TempDir::new().unwrap();
+        let temp_file = tempdir.path().join("graph");
+        let g1 = Graph::new();
+        g1.add_node(1, "Alice", NO_PROPS, None, None).unwrap();
+        g1.add_node(2, "Bob", NO_PROPS, None, None).unwrap();
+        g1.add_edge(3, "Alice", "Bob", [("kind", "friends")], None)
+            .unwrap();
+
+        g1.add_edge(
+            3,
+            "Alice",
+            "Bob",
+            [("image", Prop::from_arr::<Int32Type>(vec![3i32, 5]))],
+            None,
+        )
+        .unwrap();
+
+        g1.encode(&temp_file).unwrap();
+        let g2 = Graph::decode(&temp_file).unwrap();
+        assert_graph_equal(&g1, &g2);
+    }
+
+    #[test]
+    fn edge_metadata() {
+        let tempdir = TempDir::new().unwrap();
+        let temp_file = tempdir.path().join("graph");
+        let g1 = Graph::new();
+        let e1 = g1.add_edge(3, "Alice", "Bob", NO_PROPS, None).unwrap();
+        e1.update_metadata([("friends", true)], None)
+            .expect("Failed to update metadata");
+        g1.encode(&temp_file).unwrap();
+        let g2 = Graph::decode(&temp_file).unwrap();
+        assert_graph_equal(&g1, &g2);
+    }
+
+    #[test]
+    fn edge_layers() {
+        let tempdir = TempDir::new().unwrap();
+        let temp_file = tempdir.path().join("graph");
+        let g1 = Graph::new();
+        g1.add_edge(7, "Alice", "Bob", NO_PROPS, Some("one"))
+            .unwrap();
+        g1.add_edge(7, "Bob", "Charlie", [("friends", false)], Some("two"))
+            .unwrap();
+        g1.encode(&temp_file).unwrap();
+        let g2 = Graph::decode(&temp_file).unwrap();
+        assert_graph_equal(&g1, &g2);
+    }
+
+    #[test]
+    fn test_all_the_t_props_on_node() {
+        let mut props = vec![];
+        write_props_to_vec(&mut props);
+
+        let tempdir = TempDir::new().unwrap();
+        let temp_file = tempdir.path().join("graph");
+        let g1 = Graph::new();
+        g1.add_node(1, "Alice", props.clone(), None, None).unwrap();
+        g1.encode(&temp_file).unwrap();
+        let g2 = Graph::decode(&temp_file).unwrap();
+        assert_graph_equal(&g1, &g2);
+
+        let node = g2.node("Alice").expect("Failed to get node");
+
+        assert!(props.into_iter().all(|(name, expected)| {
+            node.properties()
+                .temporal()
+                .get(name)
+                .filter(|prop_view| {
+                    let (t, prop) = prop_view.iter().next().expect("Failed to get prop");
+                    prop == expected && t == 1
+                })
+                .is_some()
+        }))
+    }
+
+    #[test]
+    fn test_all_the_t_props_on_edge() {
+        let mut props = vec![];
+        write_props_to_vec(&mut props);
+
+        let tempdir = TempDir::new().unwrap();
+        let temp_file = tempdir.path().join("graph");
+        let g1 = Graph::new();
+        g1.add_edge(1, "Alice", "Bob", props.clone(), None).unwrap();
+        g1.encode(&temp_file).unwrap();
+        let g2 = Graph::decode(&temp_file).unwrap();
+        assert_graph_equal(&g1, &g2);
+
+        let edge = g2.edge("Alice", "Bob").expect("Failed to get edge");
+
+        assert!(props.into_iter().all(|(name, expected)| {
+            edge.properties()
+                .temporal()
+                .get(name)
+                .filter(|prop_view| {
+                    let (t, prop) = prop_view.iter().next().expect("Failed to get prop");
+                    prop == expected && t == 1
+                })
+                .is_some()
+        }))
+    }
+
+    #[test]
+    fn test_all_the_metadata_on_edge() {
+        let mut props = vec![];
+        write_props_to_vec(&mut props);
+
+        let tempdir = TempDir::new().unwrap();
+        let temp_file = tempdir.path().join("graph");
+        let g1 = Graph::new();
+        let e = g1.add_edge(1, "Alice", "Bob", NO_PROPS, Some("a")).unwrap();
+        e.update_metadata(props.clone(), Some("a"))
+            .expect("Failed to update metadata");
+        g1.encode(&temp_file).unwrap();
+        let g2 = Graph::decode(&temp_file).unwrap();
+        assert_graph_equal(&g1, &g2);
+
+        let edge = g2
+            .edge("Alice", "Bob")
+            .expect("Failed to get edge")
+            .layers("a")
+            .unwrap();
+
+        for (new, old) in edge.metadata().iter_filtered().zip(props.iter()) {
+            assert_eq!(new.0, old.0);
+            assert_eq!(new.1, old.1);
+        }
+    }
+
+    #[test]
+    fn test_all_the_metadata_on_node() {
+        let mut props = vec![];
+        write_props_to_vec(&mut props);
+
+        let tempdir = TempDir::new().unwrap();
+        let temp_file = tempdir.path().join("graph");
+        let g1 = Graph::new();
+        let n = g1.add_node(1, "Alice", NO_PROPS, None, None).unwrap();
+        n.update_metadata(props.clone())
+            .expect("Failed to update metadata");
+        g1.encode(&temp_file).unwrap();
+        let g2 = Graph::decode(&temp_file).unwrap();
+        assert_graph_equal(&g1, &g2);
+
+        let node = g2.node("Alice").expect("Failed to get node");
+
+        assert!(props.into_iter().all(|(name, expected)| {
+            node.metadata()
+                .get(name)
+                .filter(|prop| prop == &expected)
+                .is_some()
+        }))
+    }
+
+    #[test]
+    fn graph_metadata() {
+        let mut props = vec![];
+        write_props_to_vec(&mut props);
+
+        let g1 = Graph::new();
+        g1.add_metadata(props.clone())
+            .expect("Failed to add metadata");
+
+        let tempdir = TempDir::new().unwrap();
+        let temp_file = tempdir.path().join("graph");
+        g1.encode(&temp_file).unwrap();
+        let g2 = Graph::decode(&temp_file).unwrap();
+        assert_graph_equal(&g1, &g2);
+
+        props.into_iter().for_each(|(name, prop)| {
+            let id = g2.get_metadata_id(name).expect("Failed to get prop id");
+            assert_eq!(prop, g2.get_metadata(id).expect("Failed to get prop"));
+        });
+    }
+
+    #[test]
+    fn graph_temp_properties() {
+        let mut props = vec![];
+        write_props_to_vec(&mut props);
+
+        let g1 = Graph::new();
+        for t in 0..props.len() {
+            g1.add_properties(t as i64, props[t..t + 1].to_vec())
+                .expect("Failed to add metadata");
+        }
+
+        let tempdir = TempDir::new().unwrap();
+        let temp_file = tempdir.path().join("graph");
+        g1.encode(&temp_file).unwrap();
+        let g2 = Graph::decode(&temp_file).unwrap();
+        assert_graph_equal(&g1, &g2);
+
+        props
+            .into_iter()
+            .enumerate()
+            .for_each(|(expected_t, (name, expected))| {
+                for (t, prop) in g2
+                    .properties()
+                    .temporal()
+                    .get(name)
+                    .expect("Failed to get prop view")
+                {
+                    assert_eq!(prop, expected);
+                    assert_eq!(t, expected_t as i64);
+                }
+            });
+    }
+
+    #[test]
+    #[ignore = "Disabled until metadata is implemented correctly"]
+    fn test_incremental_writing_on_graph() {
+        let g = Graph::new();
+        let mut props = vec![];
+        write_props_to_vec(&mut props);
+        let temp_cache_file = tempfile::tempdir().unwrap();
+        let folder = GraphFolder::from(&temp_cache_file);
+
+        assert_metadata_correct(&folder, &g);
+
+        for t in 0..props.len() {
+            g.add_properties(t as i64, props[t..t + 1].to_vec())
+                .expect("Failed to add metadata");
+        }
+
+        g.add_metadata(props.clone())
+            .expect("Failed to add metadata");
+
+        let n = g.add_node(1, "Alice", NO_PROPS, None, None).unwrap();
+        n.update_metadata(props.clone())
+            .expect("Failed to update metadata");
+
+        let e = g.add_edge(1, "Alice", "Bob", NO_PROPS, Some("a")).unwrap();
+        e.update_metadata(props.clone(), Some("a"))
+            .expect("Failed to update metadata");
+
+        assert_metadata_correct(&folder, &g);
+
+        g.add_edge(2, "Alice", "Bob", props.clone(), None).unwrap();
+        g.add_node(1, "Charlie", props.clone(), None, None).unwrap();
+
+        g.add_edge(7, "Alice", "Bob", NO_PROPS, Some("one"))
+            .unwrap();
+        g.add_edge(7, "Bob", "Charlie", [("friends", false)], Some("two"))
+            .unwrap();
+
+        let g2 = Graph::decode(&temp_cache_file).unwrap();
+
+        assert_graph_equal(&g, &g2);
+        assert_metadata_correct(&folder, &g);
+    }
+
+    #[test]
+    #[ignore = "Disabled until metadata is implemented correctly"]
+    fn test_incremental_writing_on_persistent_graph() {
+        let g = PersistentGraph::new();
+        let mut props = vec![];
+
+        write_props_to_vec(&mut props);
+
+        let temp_cache_file = tempfile::tempdir().unwrap();
+        let folder = GraphFolder::from(&temp_cache_file);
+
+        for t in 0..props.len() {
+            g.add_properties(t as i64, props[t..t + 1].to_vec())
+                .expect("Failed to add metadata");
+        }
+
+        g.add_metadata(props.clone())
+            .expect("Failed to add metadata");
+
+        let n = g.add_node(1, "Alice", NO_PROPS, None, None).unwrap();
+        n.update_metadata(props.clone())
+            .expect("Failed to update metadata");
+
+        let e = g.add_edge(1, "Alice", "Bob", NO_PROPS, Some("a")).unwrap();
+        e.update_metadata(props.clone(), Some("a"))
+            .expect("Failed to update metadata");
+
+        assert_metadata_correct(&folder, &g);
+
+        g.add_edge(2, "Alice", "Bob", props.clone(), None).unwrap();
+        g.add_node(1, "Charlie", props.clone(), None, None).unwrap();
+
+        g.add_edge(7, "Alice", "Bob", NO_PROPS, Some("one"))
+            .unwrap();
+        g.add_edge(7, "Bob", "Charlie", [("friends", false)], Some("two"))
+            .unwrap();
+
+        let g2 = PersistentGraph::decode(&temp_cache_file).unwrap();
+
+        assert_graph_equal(&g, &g2);
+        assert_metadata_correct(&folder, &g);
+    }
+
+    #[test]
+    fn encode_decode_prop_test() {
+        proptest!(|(edges in build_edge_list(100, 100))| {
+            let g = build_graph_from_edge_list(&edges);
+            let bytes = g.encode_to_bytes().unwrap();
+            let g2 = Graph::decode_from_bytes(&bytes).unwrap();
+            assert_graph_equal(&g, &g2);
+        })
+    }
+
+    fn write_props_to_vec(props: &mut Vec<(&str, Prop)>) {
+        props.push(("name", Prop::Str("Alice".into())));
+        props.push(("age", Prop::U32(47)));
+        props.push(("score", Prop::I32(27)));
+        props.push(("is_adult", Prop::Bool(true)));
+        props.push(("height", Prop::F32(1.75)));
+        props.push(("weight", Prop::F64(75.5)));
+        props.push((
+            "children",
+            Prop::from(vec![Prop::Str("Bob".into()), Prop::Str("Charlie".into())]),
+        ));
+        props.push((
+            "properties",
+            Prop::map(props.iter().map(|(k, v)| (ArcStr::from(*k), v.clone()))),
+        ));
+        let fmt = "%Y-%m-%d %H:%M:%S";
+        props.push((
+            "time",
+            Prop::NDTime(
+                NaiveDateTime::parse_from_str("+10000-09-09 01:46:39", fmt)
+                    .expect("Failed to parse time"),
+            ),
+        ));
+
+        props.push((
+            "dtime",
+            Prop::DTime(
+                DateTime::parse_from_rfc3339("2021-09-09T01:46:39Z")
+                    .unwrap()
+                    .into(),
+            ),
+        ));
+
+        props.push((
+            "array",
+            Prop::from_arr::<UInt8Type>(vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]),
+        ));
+    }
+}
diff --git a/raphtory/tests/subgraph_tests.rs b/raphtory/tests/subgraph_tests.rs
index 9648093909..6e18f7b76d 100644
--- a/raphtory/tests/subgraph_tests.rs
+++ b/raphtory/tests/subgraph_tests.rs
@@ -9,14 +9,15 @@ use raphtory::{
     test_utils::{build_graph, build_graph_strat},
 };
 use raphtory_storage::mutation::addition_ops::InternalAdditionOps;
+use serde_json::json;
 use std::collections::BTreeSet;
 
 #[test]
 fn test_materialize_no_edges() {
     let graph = Graph::new();
 
-    graph.add_node(1, 1, NO_PROPS, None).unwrap();
-    graph.add_node(2, 2, NO_PROPS, None).unwrap();
+    graph.add_node(1, 1, NO_PROPS, None, None).unwrap();
+    graph.add_node(2, 2, NO_PROPS, None, None).unwrap();
 
     test_storage!(&graph, |graph| {
         let sg = graph.subgraph([1, 2, 1]); // <- duplicated nodes should have no effect
@@ -84,10 +85,10 @@ fn layer_materialize() {
 #[test]
 fn test_cc() {
     let graph = Graph::new();
-    graph.add_node(0, 0, NO_PROPS, None).unwrap();
-    graph.add_node(0, 3, NO_PROPS, None).unwrap();
-    graph.add_node(1, 2, NO_PROPS, None).unwrap();
-    graph.add_node(1, 4, NO_PROPS, None).unwrap();
+    graph.add_node(0, 0, NO_PROPS, None, None).unwrap();
+    graph.add_node(0, 3, NO_PROPS, None, None).unwrap();
+    graph.add_node(1, 2, NO_PROPS, None, None).unwrap();
+    graph.add_node(1, 4, NO_PROPS, None, None).unwrap();
     graph.add_edge(0, 0, 1, NO_PROPS, Some("1")).unwrap();
     graph.add_edge(1, 3, 4, NO_PROPS, Some("1")).unwrap();
     let sg = graph.subgraph([0, 1, 3, 4]);
@@ -212,7 +213,9 @@ pub mod test_filters_node_subgraph {
             ];
 
             for (id, name, props) in &nodes {
-                graph.add_node(*id, name, props.clone(), None).unwrap();
+                graph
+                    .add_node(*id, name, props.clone(), None, None)
+                    .unwrap();
             }
 
             graph
@@ -520,16 +523,28 @@ fn nodes_without_updates_are_filtered() {
 
 #[test]
 fn materialize_proptest() {
-    proptest!(|(graph in build_graph_strat(10, 10, false), nodes in subsequence((0..10).collect::<Vec<_>>(), 0..10))| {
+    proptest!(|(graph in build_graph_strat(10, 10, 10, 10, false), nodes in subsequence((0..10).collect::<Vec<_>>(), 0..10))| {
         let graph = Graph::from(build_graph(&graph));
         let subgraph = graph.subgraph(nodes);
         assert_graph_equal(&subgraph, &subgraph.materialize().unwrap());
     })
 }
 
+#[test]
+fn materialize_proptest_failure() {
+    let graph_f = serde_json::from_value(json!({"nodes":{},"edges":[[[1,1,"a"],{"props":{"t_props":[[0,[]]],"c_props":[]},"deletions":[]}],[[0,0,null],{"props":{"t_props":[[0,[]]],"c_props":[]},"deletions":[]}]]})).unwrap();
+    let graph = Graph::from(build_graph(&graph_f));
+    let subgraph = graph.subgraph([1]);
+    let nodes = subgraph.default_layer().nodes().id().collect_vec();
+    dbg!(nodes);
+    assert_eq!(subgraph.default_layer().count_nodes(), 0);
+    let materialised = subgraph.materialize().unwrap();
+    assert_graph_equal(&subgraph, &materialised);
+}
+
 #[test]
 fn materialize_persistent_proptest() {
-    proptest!(|(graph in build_graph_strat(10, 10, true), nodes in subsequence((0..10).collect::<Vec<_>>(), 0..10))| {
+    proptest!(|(graph in build_graph_strat(10, 10, 10, 10, true), nodes in subsequence((0..10).collect::<Vec<_>>(), 0..10))| {
         let graph = PersistentGraph::from(build_graph(&graph));
         let subgraph = graph.subgraph(nodes);
         assert_graph_equal(&subgraph, &subgraph.materialize().unwrap());
diff --git a/raphtory/tests/test_deletions.rs b/raphtory/tests/test_deletions.rs
index 642565fcd9..58ff3ad0eb 100644
--- a/raphtory/tests/test_deletions.rs
+++ b/raphtory/tests/test_deletions.rs
@@ -16,6 +16,7 @@ use raphtory_api::core::{
     storage::timeindex::{AsTime, EventTime},
 };
 use raphtory_storage::mutation::addition_ops::InternalAdditionOps;
+use rayon::ThreadPoolBuilder;
 use std::ops::Range;
 
 #[test]
@@ -165,7 +166,7 @@ fn test_materialize_only_deletion() {
 
 #[test]
 fn materialize_prop_test() {
-    proptest!(|(graph_f in build_graph_strat(10, 10, true))| {
+    proptest!(|(graph_f in build_graph_strat(10, 10, 10, 10, true))| {
         let g = PersistentGraph::from(build_graph(&graph_f));
         let gm = g.materialize().unwrap();
         assert_graph_equal(&g, &gm);
@@ -174,7 +175,7 @@ fn materialize_prop_test() {
 
 #[test]
 fn materialize_window_prop_test() {
-    proptest!(|(graph_f in build_graph_strat(10, 10, true), w in any::<Range<i64>>())| {
+    proptest!(|(graph_f in build_graph_strat(10, 10, 10, 10, true), w in any::<Range<i64>>())| {
         let g = PersistentGraph::from(build_graph(&graph_f));
         let gw = g.window(w.start, w.end);
         let gmw = gw.materialize().unwrap();
@@ -240,14 +241,29 @@ fn test_deletion_at_window_start() {
 
 #[test]
 fn materialize_window_layers_prop_test() {
-    proptest!(|(graph_f in build_graph_strat(10, 10, true), w in any::<Range<i64>>(), l in subsequence(&["a", "b"], 0..=2))| {
-        let g = PersistentGraph::from(build_graph(&graph_f));
-        let glw = g.valid_layers(l).window(w.start, w.end);
-        let gmlw = glw.materialize().unwrap();
-        assert_persistent_materialize_graph_equal(&glw, &gmlw);
+    proptest!(|(graph_f in build_graph_strat(10, 10, 10, 10, true), w in any::<Range<i64>>(), l in subsequence(&["a", "b"], 0..=2), num_threads in 1..=16usize)| {
+        let pool = ThreadPoolBuilder::new().num_threads(num_threads).build().unwrap();
+        pool.install(|| {
+            let g = PersistentGraph::from(build_graph(&graph_f));
+            let glw = g.valid_layers(l.clone()).window(w.start, w.end);
+            let gmlw = glw.materialize().unwrap();
+            assert_persistent_materialize_graph_equal(&glw, &gmlw);
+        })
+
     })
 }
 
+#[test]
+fn materialize_window_multilayer() {
+    let g = PersistentGraph::new();
+    g.add_edge(1, 0, 0, NO_PROPS, None).unwrap();
+    g.delete_edge(3, 0, 0, Some("a")).unwrap();
+    let w = 0..10;
+    let glw = g.valid_layers("a").window(w.start, w.end);
+    let gmlw = glw.materialize().unwrap();
+    assert_persistent_materialize_graph_equal(&glw, &gmlw);
+}
+
 #[test]
 fn test_materialize_deleted_edge() {
     let g = PersistentGraph::new();
@@ -305,8 +321,8 @@ fn materialize_broken_time() {
 #[test]
 fn test_materialize_window_start_before_node_add() {
     let g = PersistentGraph::new();
-    g.add_node(-1, 0, [("test", "test")], None).unwrap();
-    g.add_node(5, 0, [("test", "blob")], None).unwrap();
+    g.add_node(-1, 0, [("test", "test")], None, None).unwrap();
+    g.add_node(5, 0, [("test", "blob")], None, None).unwrap();
     g.add_edge(0, 0, 0, NO_PROPS, None).unwrap();
     let gw = g.window(-5, 8);
     let gmw = gw.materialize().unwrap();
@@ -370,7 +386,7 @@ fn test_materialize_window() {
 #[test]
 fn test_materialize_window_node_props() {
     let g = Graph::new();
-    g.add_node(0, 1, [("test", "test")], None).unwrap();
+    g.add_node(0, 1, [("test", "test")], None, None).unwrap();
 
     test_storage!(&g, |g| {
         let g = g.persistent_graph();
@@ -435,6 +451,21 @@ fn test_edge_properties() {
     );
 }
 
+#[test]
+fn test_multiple_edge_properties() {
+    let g = PersistentGraph::new();
+    g.add_edge(0, 0, 1, [("test1", "test1")], None).unwrap();
+    g.add_edge(1, 0, 1, [("test2", "test2")], None).unwrap();
+
+    let e = g.edge(0, 1).unwrap();
+    assert_eq!(e.properties().get("test1").unwrap_str(), "test1");
+    assert_eq!(e.properties().get("test2").unwrap_str(), "test2");
+
+    let ew = e.window(1, 10);
+    assert_eq!(ew.properties().get("test1").unwrap_str(), "test1");
+    assert_eq!(ew.properties().get("test2").unwrap_str(), "test2");
+}
+
 #[test]
 fn test_edge_history() {
     let g = PersistentGraph::new();
@@ -566,6 +597,14 @@ fn test_deletion_multiple_layers() {
     check_valid(&e_layer_2.at(10));
 }
 
+#[test]
+fn test_materialize_node_type() {
+    let g = PersistentGraph::new();
+    g.delete_edge(0, 0, 0, None).unwrap();
+    g.node(0).unwrap().set_node_type("test").unwrap();
+    assert_graph_equal(&g, &g.materialize().unwrap());
+}
+
 #[test]
 fn test_edge_is_valid() {
     let g = PersistentGraph::new();
@@ -635,10 +674,10 @@ fn test_edge_latest_time() {
 fn test_node_property_semantics() {
     let g = PersistentGraph::new();
     let _v = g
-        .add_node(1, 1, [("test_prop", "test value")], None)
+        .add_node(1, 1, [("test_prop", "test value")], None, None)
         .unwrap();
     let v = g
-        .add_node(11, 1, [("test_prop", "test value 2")], None)
+        .add_node(11, 1, [("test_prop", "test value 2")], None, None)
         .unwrap();
     let v_from_graph = g.at(10).node(1).unwrap();
     assert_eq!(v.properties().get("test_prop").unwrap_str(), "test value 2");
@@ -732,7 +771,7 @@ fn test_exploded_latest_time_deleted() {
 #[test]
 fn test_empty_window_has_no_nodes() {
     let g = PersistentGraph::new();
-    g.add_node(1, 1, NO_PROPS, None).unwrap();
+    g.add_node(1, 1, NO_PROPS, None, None).unwrap();
     assert_eq!(g.window(2, 2).count_nodes(), 0);
     assert_eq!(g.window(1, 1).count_nodes(), 0);
     assert_eq!(g.window(0, 0).count_nodes(), 0);
@@ -1074,11 +1113,11 @@ fn test_deletion_at_start() {
 fn multiple_node_updates_at_same_time() {
     let g = PersistentGraph::new();
 
-    g.add_node(1, 1, [("prop1", 1)], None).unwrap();
-    g.add_node(2, 1, [("prop1", 2)], None).unwrap();
-    g.add_node(2, 1, [("prop1", 3)], None).unwrap();
-    g.add_node(8, 1, [("prop1", 4)], None).unwrap();
-    g.add_node(9, 1, [("prop1", 5)], None).unwrap();
+    g.add_node(1, 1, [("prop1", 1)], None, None).unwrap();
+    g.add_node(2, 1, [("prop1", 2)], None, None).unwrap();
+    g.add_node(2, 1, [("prop1", 3)], None, None).unwrap();
+    g.add_node(8, 1, [("prop1", 4)], None, None).unwrap();
+    g.add_node(9, 1, [("prop1", 5)], None, None).unwrap();
 
     assert_eq!(
         g.window(2, 10)
@@ -1097,7 +1136,7 @@ fn multiple_node_updates_at_same_time() {
 #[test]
 fn filtering_all_layers_keeps_explicitly_added_nodes() {
     let g = PersistentGraph::new();
-    g.add_node(0, 0, [("prop1", false)], None).unwrap();
+    g.add_node(0, 0, [("prop1", false)], None, None).unwrap();
     let view = g.valid_layers(Layer::None).window(0, 1);
     assert_eq!(view.count_nodes(), 1);
     assert_eq!(view.count_edges(), 0);
diff --git a/raphtory/tests/test_edge.rs b/raphtory/tests/test_edge.rs
index 196d19f787..1f22b24d6f 100644
--- a/raphtory/tests/test_edge.rs
+++ b/raphtory/tests/test_edge.rs
@@ -1,6 +1,17 @@
 use itertools::Itertools;
-use raphtory::{prelude::*, test_storage, test_utils::test_graph};
-use raphtory_api::core::storage::{arc_str::ArcStr, timeindex::AsTime};
+use raphtory::{
+    db::{
+        api::view::Filter,
+        graph::views::filter::model::{EdgeViewFilterOps, ViewWrapOps},
+    },
+    prelude::*,
+    test_storage,
+    test_utils::test_graph,
+};
+use raphtory_api::core::{
+    entities::LayerId,
+    storage::{arc_str::ArcStr, timeindex::AsTime},
+};
 use std::collections::HashMap;
 
 #[test]
@@ -14,7 +25,7 @@ fn test_properties() {
         let e1_w = graph.window(0, 1).edge(1, 2).unwrap();
         assert_eq!(
             HashMap::from_iter(e1.properties().as_vec()),
-            props.clone().into()
+            props.into_iter().collect::<HashMap<_, _>>()
         );
         assert!(e1_w.properties().as_vec().is_empty())
     });
@@ -100,7 +111,7 @@ fn test_property_additions() {
             .into_iter()
             .map(|(k, v)| (ArcStr::from(k), v.into_prop()))
             .chain([(ArcStr::from("test2"), "_default".into_prop())])
-            .collect()
+            .collect::<HashMap<_, _>>()
     );
     assert_eq!(
         e.layers("test2").unwrap().properties().as_map(),
@@ -108,7 +119,7 @@ fn test_property_additions() {
             .into_iter()
             .map(|(k, v)| (ArcStr::from(k), v.into_prop()))
             .chain([(ArcStr::from("test2"), "test2".into_prop())])
-            .collect()
+            .collect::<HashMap<_, _>>()
     );
     assert_eq!(e1_w.properties().as_map(), HashMap::default())
 }
@@ -117,7 +128,7 @@ fn test_property_additions() {
 fn test_metadata_additions() {
     let g = Graph::new();
     let e = g.add_edge(0, 1, 2, NO_PROPS, Some("test")).unwrap();
-    assert_eq!(e.edge.layer(), Some(0));
+    assert_eq!(e.edge.layer(), Some(LayerId(1))); // 0 is static graph
     assert!(e.add_metadata([("test1", "test1")], None).is_ok()); // adds properties to layer `"test"`
     assert!(e.add_metadata([("test", "test")], Some("test2")).is_err()); // cannot add properties to a different layer
     e.add_metadata([("test", "test")], Some("test")).unwrap(); // layer is consistent
@@ -140,3 +151,40 @@ fn test_layers_earliest_time() {
     let e = g.add_edge(1, 1, 2, NO_PROPS, Some("test")).unwrap();
     assert_eq!(e.earliest_time().map(|t| t.t()), Some(1));
 }
+
+#[test]
+fn test_edge_layers() {
+    let graph = Graph::new();
+
+    graph
+        .add_edge(0, 1, 2, NO_PROPS, Some("fire_nation"))
+        .unwrap();
+    graph
+        .add_edge(0, 2, 3, [("a", "test")], Some("fire_nation"))
+        .unwrap();
+    graph
+        .add_edge(0, 3, 4, [("b", 4)], Some("air_nomads"))
+        .unwrap();
+
+    let filter_expr = EdgeFilter.layer("fire_nation").is_active();
+    let ids = graph
+        .filter(filter_expr)
+        .unwrap()
+        .edges()
+        .iter()
+        .map(|n| n.src().name() + "->" + &n.dst().name())
+        .collect::<Vec<_>>();
+
+    assert_eq!(ids, ["1->2", "2->3"]);
+
+    let filter_expr = EdgeFilter.layer("air_nomads").is_active();
+    let ids = graph
+        .filter(filter_expr)
+        .unwrap()
+        .edges()
+        .iter()
+        .map(|n| n.src().name() + "->" + &n.dst().name())
+        .collect::<Vec<_>>();
+
+    assert_eq!(ids, ["3->4"]);
+}
diff --git a/raphtory/tests/test_exploded_edges.rs b/raphtory/tests/test_exploded_edges.rs
index e207deb810..820c91963b 100644
--- a/raphtory/tests/test_exploded_edges.rs
+++ b/raphtory/tests/test_exploded_edges.rs
@@ -4,9 +4,15 @@ use raphtory::{prelude::*, test_storage};
 #[test]
 fn test_add_node_properties_ordered_by_event_id() {
     let graph: Graph = Graph::new();
-    graph.add_node((0, 3), 0, [("prop", "1")], None).unwrap();
-    graph.add_node((0, 2), 0, [("prop", "2")], None).unwrap();
-    graph.add_node((0, 1), 0, [("prop", "3")], None).unwrap();
+    graph
+        .add_node((0, 3), 0, [("prop", "1")], None, None)
+        .unwrap();
+    graph
+        .add_node((0, 2), 0, [("prop", "2")], None, None)
+        .unwrap();
+    graph
+        .add_node((0, 1), 0, [("prop", "3")], None, None)
+        .unwrap();
 
     let props = graph
         .node("0")
@@ -30,9 +36,15 @@ fn test_add_node_properties_ordered_by_event_id() {
 #[test]
 fn test_add_node_properties_overwritten_for_same_event_id() {
     let graph: Graph = Graph::new();
-    graph.add_node((0, 1), 0, [("prop", "1")], None).unwrap();
-    graph.add_node((0, 1), 0, [("prop", "2")], None).unwrap();
-    graph.add_node((0, 1), 0, [("prop", "3")], None).unwrap();
+    graph
+        .add_node((0, 1), 0, [("prop", "1")], None, None)
+        .unwrap();
+    graph
+        .add_node((0, 1), 0, [("prop", "2")], None, None)
+        .unwrap();
+    graph
+        .add_node((0, 1), 0, [("prop", "3")], None, None)
+        .unwrap();
 
     let props = graph
         .node(0)
@@ -50,9 +62,15 @@ fn test_add_node_properties_overwritten_for_same_event_id() {
     assert_eq!(props, vec!["3".to_string()]);
 
     let graph: Graph = Graph::new();
-    graph.add_node((0, 1), 0, [("prop", "1")], None).unwrap();
-    graph.add_node((0, 2), 0, [("prop", "2")], None).unwrap();
-    graph.add_node((0, 2), 0, [("prop", "3")], None).unwrap();
+    graph
+        .add_node((0, 1), 0, [("prop", "1")], None, None)
+        .unwrap();
+    graph
+        .add_node((0, 2), 0, [("prop", "2")], None, None)
+        .unwrap();
+    graph
+        .add_node((0, 2), 0, [("prop", "3")], None, None)
+        .unwrap();
 
     let props = graph
         .node(0)
@@ -73,9 +91,15 @@ fn test_add_node_properties_overwritten_for_same_event_id() {
 #[test]
 fn test_create_node_properties_ordered_by_event_id() {
     let graph: Graph = Graph::new();
-    graph.create_node((0, 3), 0, [("prop", "1")], None).unwrap();
-    graph.add_node((0, 2), 0, [("prop", "2")], None).unwrap();
-    graph.add_node((0, 1), 0, [("prop", "3")], None).unwrap();
+    graph
+        .create_node((0, 3), 0, [("prop", "1")], None, None)
+        .unwrap();
+    graph
+        .add_node((0, 2), 0, [("prop", "2")], None, None)
+        .unwrap();
+    graph
+        .add_node((0, 1), 0, [("prop", "3")], None, None)
+        .unwrap();
 
     let props = graph
         .node("0")
@@ -99,9 +123,15 @@ fn test_create_node_properties_ordered_by_event_id() {
 #[test]
 fn test_create_node_properties_overwritten_for_same_event_id() {
     let graph: Graph = Graph::new();
-    graph.create_node((0, 1), 0, [("prop", "1")], None).unwrap();
-    graph.add_node((0, 1), 0, [("prop", "2")], None).unwrap();
-    graph.add_node((0, 1), 0, [("prop", "3")], None).unwrap();
+    graph
+        .create_node((0, 1), 0, [("prop", "1")], None, None)
+        .unwrap();
+    graph
+        .add_node((0, 1), 0, [("prop", "2")], None, None)
+        .unwrap();
+    graph
+        .add_node((0, 1), 0, [("prop", "3")], None, None)
+        .unwrap();
 
     let props = graph
         .node(0)
@@ -119,9 +149,15 @@ fn test_create_node_properties_overwritten_for_same_event_id() {
     assert_eq!(props, vec!["3".to_string()]);
 
     let graph: Graph = Graph::new();
-    graph.create_node((0, 1), 0, [("prop", "1")], None).unwrap();
-    graph.add_node((0, 2), 0, [("prop", "2")], None).unwrap();
-    graph.add_node((0, 2), 0, [("prop", "3")], None).unwrap();
+    graph
+        .create_node((0, 1), 0, [("prop", "1")], None, None)
+        .unwrap();
+    graph
+        .add_node((0, 2), 0, [("prop", "2")], None, None)
+        .unwrap();
+    graph
+        .add_node((0, 2), 0, [("prop", "3")], None, None)
+        .unwrap();
 
     let props = graph
         .node(0)
@@ -272,22 +308,22 @@ fn test_add_properties_properties_overwritten_for_same_event_id() {
 #[test]
 fn test_node_add_updates_properties_ordered_by_event_id() {
     let graph: Graph = Graph::new();
-    graph.add_node(0, 0, NO_PROPS, None).unwrap();
+    graph.add_node(0, 0, NO_PROPS, None, None).unwrap();
 
     graph
         .node(0)
         .unwrap()
-        .add_updates((0, 3), [("prop", "1")])
+        .add_updates((0, 3), [("prop", "1")], None)
         .unwrap();
     graph
         .node(0)
         .unwrap()
-        .add_updates((0, 2), [("prop", "2")])
+        .add_updates((0, 2), [("prop", "2")], None)
         .unwrap();
     graph
         .node(0)
         .unwrap()
-        .add_updates((0, 1), [("prop", "3")])
+        .add_updates((0, 1), [("prop", "3")], None)
         .unwrap();
 
     let props = graph
@@ -312,24 +348,24 @@ fn test_node_add_updates_properties_ordered_by_event_id() {
 #[test]
 fn test_node_add_updates_properties_overwritten_for_same_event_id() {
     let graph: Graph = Graph::new();
-    graph.add_node(0, 0, NO_PROPS, None).unwrap();
-    graph.add_node(0, 0, NO_PROPS, None).unwrap();
-    graph.add_node(0, 0, NO_PROPS, None).unwrap();
+    graph.add_node(0, 0, NO_PROPS, None, None).unwrap();
+    graph.add_node(0, 0, NO_PROPS, None, None).unwrap();
+    graph.add_node(0, 0, NO_PROPS, None, None).unwrap();
 
     graph
         .node(0)
         .unwrap()
-        .add_updates((0, 1), [("prop", "1")])
+        .add_updates((0, 1), [("prop", "1")], None)
         .unwrap();
     graph
         .node(0)
         .unwrap()
-        .add_updates((0, 1), [("prop", "2")])
+        .add_updates((0, 1), [("prop", "2")], None)
         .unwrap();
     graph
         .node(0)
         .unwrap()
-        .add_updates((0, 1), [("prop", "3")])
+        .add_updates((0, 1), [("prop", "3")], None)
         .unwrap();
 
     let props = graph
@@ -348,28 +384,28 @@ fn test_node_add_updates_properties_overwritten_for_same_event_id() {
     assert_eq!(props, vec!["3".to_string()]);
 
     let graph: Graph = Graph::new();
-    graph.add_node(0, 0, NO_PROPS, None).unwrap();
-    graph.add_node(0, 0, NO_PROPS, None).unwrap();
-    graph.add_node(0, 0, NO_PROPS, None).unwrap();
+    graph.add_node(0, 0, NO_PROPS, None, None).unwrap();
+    graph.add_node(0, 0, NO_PROPS, None, None).unwrap();
+    graph.add_node(0, 0, NO_PROPS, None, None).unwrap();
 
-    graph.add_node(0, 0, NO_PROPS, None).unwrap();
-    graph.add_node(0, 0, NO_PROPS, None).unwrap();
-    graph.add_node(0, 0, NO_PROPS, None).unwrap();
+    graph.add_node(0, 0, NO_PROPS, None, None).unwrap();
+    graph.add_node(0, 0, NO_PROPS, None, None).unwrap();
+    graph.add_node(0, 0, NO_PROPS, None, None).unwrap();
 
     graph
         .node(0)
         .unwrap()
-        .add_updates((0, 1), [("prop", "1")])
+        .add_updates((0, 1), [("prop", "1")], None)
         .unwrap();
     graph
         .node(0)
         .unwrap()
-        .add_updates((0, 2), [("prop", "2")])
+        .add_updates((0, 2), [("prop", "2")], None)
         .unwrap();
     graph
         .node(0)
         .unwrap()
-        .add_updates((0, 2), [("prop", "3")])
+        .add_updates((0, 2), [("prop", "3")], None)
         .unwrap();
 
     let props = graph
diff --git a/raphtory/tests/test_filters.rs b/raphtory/tests/test_filters.rs
index 2a8ff85a3a..37038c2f0d 100644
--- a/raphtory/tests/test_filters.rs
+++ b/raphtory/tests/test_filters.rs
@@ -5,7 +5,6 @@ use raphtory::{
 
 #[cfg(test)]
 mod test_composite_filters {
-
     use raphtory::{
         db::graph::views::filter::model::{
             edge_filter::EdgeFilter, filter::Filter, node_filter::NodeFilter,
@@ -132,8 +131,7 @@ mod test_property_semantics {
                         assert_filter_nodes_results, assert_search_nodes_results, TestVariants,
                     },
                     views::filter::model::{
-                        node_filter::NodeFilter,
-                        property_filter::ops::{ListAggOps, PropertyFilterOps},
+                        node_filter::NodeFilter, property_filter::ops::PropertyFilterOps,
                         PropertyFilterFactory, TemporalPropertyFilterFactory,
                     },
                 },
@@ -176,7 +174,9 @@ mod test_property_semantics {
             ];
 
             for (id, label, props) in nodes.iter() {
-                graph.add_node(*id, label, props.clone(), None).unwrap();
+                graph
+                    .add_node(*id, label, props.clone(), None, None)
+                    .unwrap();
             }
 
             let metadata = [
@@ -220,7 +220,9 @@ mod test_property_semantics {
             ];
 
             for (id, label, props) in nodes.iter() {
-                graph.add_node(*id, label, props.clone(), None).unwrap();
+                graph
+                    .add_node(*id, label, props.clone(), None, None)
+                    .unwrap();
             }
 
             graph
@@ -337,14 +339,14 @@ mod test_property_semantics {
                 IdentityGraphTransformer,
                 filter.clone(),
                 &expected_results,
-                TestVariants::NonDiskOnly,
+                TestVariants::All,
             );
             assert_search_nodes_results(
                 init_graph,
                 IdentityGraphTransformer,
                 filter,
                 &expected_results,
-                TestVariants::NonDiskOnly,
+                TestVariants::All,
             );
         }
 
@@ -383,7 +385,9 @@ mod test_property_semantics {
                 let nodes = [(2, "N1", vec![("q1", Prop::U64(0u64))]), (2, "N2", vec![])];
 
                 for (id, label, props) in nodes.iter() {
-                    graph.add_node(*id, label, props.clone(), None).unwrap();
+                    graph
+                        .add_node(*id, label, props.clone(), None, None)
+                        .unwrap();
                 }
 
                 let metadata = [
@@ -436,7 +440,9 @@ mod test_property_semantics {
                 ];
 
                 for (id, label, props) in nodes.iter() {
-                    graph.add_node(*id, label, props.clone(), None).unwrap();
+                    graph
+                        .add_node(*id, label, props.clone(), None, None)
+                        .unwrap();
                 }
 
                 graph
@@ -449,14 +455,14 @@ mod test_property_semantics {
                 IdentityGraphTransformer,
                 filter.clone(),
                 &expected_results,
-                TestVariants::NonDiskOnly,
+                TestVariants::All,
             );
             assert_search_nodes_results(
                 init_graph,
                 IdentityGraphTransformer,
                 filter,
                 &expected_results,
-                TestVariants::NonDiskOnly,
+                TestVariants::All,
             );
         }
     }
@@ -726,7 +732,7 @@ mod test_property_semantics {
                 IdentityGraphTransformer,
                 filter.clone(),
                 &expected_results,
-                TestVariants::NonDiskOnly,
+                TestVariants::All,
             );
         }
 
@@ -913,7 +919,7 @@ mod test_property_semantics {
                 IdentityGraphTransformer,
                 filter.clone(),
                 &expected_results,
-                TestVariants::NonDiskOnly,
+                TestVariants::All,
             );
         }
 
@@ -1128,7 +1134,7 @@ fn init_nodes_graph<
     ];
 
     for (time, id, props, node_type) in nodes {
-        graph.add_node(time, id, props, node_type).unwrap();
+        graph.add_node(time, id, props, node_type, None).unwrap();
     }
 
     let metadata = [
@@ -1276,7 +1282,7 @@ fn init_nodes_graph_with_num_ids<
     ];
 
     for (time, id, props, node_type) in nodes {
-        graph.add_node(time, id, props, node_type).unwrap();
+        graph.add_node(time, id, props, node_type, None).unwrap();
     }
 
     graph
@@ -1304,7 +1310,7 @@ fn init_nodes_graph_with_str_ids<
     ];
 
     for (time, id, node_type) in nodes {
-        graph.add_node(time, id, NO_PROPS, node_type).unwrap();
+        graph.add_node(time, id, NO_PROPS, node_type, None).unwrap();
     }
 
     graph
@@ -1658,10 +1664,7 @@ mod test_node_filter {
     use raphtory::{
         algorithms::alternating_mask::alternating_mask,
         db::{
-            api::{
-                state::{GenericNodeState, TypedNodeState},
-                view::{filter_ops::NodeSelect, Filter},
-            },
+            api::view::{filter_ops::NodeSelect, Filter},
             graph::{
                 assertions::{
                     assert_filter_nodes_results, assert_search_nodes_results,
@@ -1669,15 +1672,16 @@ mod test_node_filter {
                 },
                 views::filter::model::{
                     node_filter::ops::{NodeFilterOps, NodeIdFilterOps},
-                    ComposableFilter, CompositeNodeFilter, NodeViewFilterOps,
-                    PropertyFilterFactory, TryAsCompositeFilter, ViewWrapOps,
+                    ComposableFilter, CompositeNodeFilter, NodeViewFilterOps, TryAsCompositeFilter,
+                    ViewWrapOps,
                 },
             },
         },
-        prelude::{AdditionOps, Graph, GraphViewOps, NodeFilter, NodeViewOps, TimeOps, NO_PROPS},
+        prelude::{
+            AdditionOps, Graph, GraphViewOps, NodeFilter, NodeStateOps, NodeViewOps, TimeOps,
+            NO_PROPS,
+        },
     };
-    use raphtory_api::core::entities::VID;
-    use std::collections::HashMap;
 
     #[test]
     fn test_node_list_is_preserved() {
@@ -1734,7 +1738,7 @@ mod test_node_filter {
 
     #[test]
     fn test_filter_nodes_for_node_name_in() {
-        let filter = NodeFilter::name().is_in(vec!["1".into()]);
+        let filter = NodeFilter::name().is_in(vec!["1"]);
         let expected_results = vec!["1"];
         assert_filter_nodes_results(
             init_nodes_graph,
@@ -1751,7 +1755,7 @@ mod test_node_filter {
             TestVariants::All,
         );
 
-        let filter = NodeFilter::name().is_in(vec!["".into()]);
+        let filter = NodeFilter::name().is_in(vec![""]);
         let expected_results = Vec::<&str>::new();
         assert_filter_nodes_results(
             init_nodes_graph,
@@ -1768,7 +1772,7 @@ mod test_node_filter {
             TestVariants::All,
         );
 
-        let filter = NodeFilter::name().is_in(vec!["2".into(), "3".into()]);
+        let filter = NodeFilter::name().is_in(vec!["2", "3"]);
         let expected_results = vec!["2", "3"];
         assert_filter_nodes_results(
             init_nodes_graph,
@@ -1788,7 +1792,7 @@ mod test_node_filter {
 
     #[test]
     fn test_filter_nodes_for_node_name_not_in() {
-        let filter = NodeFilter::name().is_not_in(vec!["1".into()]);
+        let filter = NodeFilter::name().is_not_in(vec!["1"]);
         let expected_results = vec!["2", "3", "4"];
         assert_filter_nodes_results(
             init_nodes_graph,
@@ -1805,7 +1809,7 @@ mod test_node_filter {
             TestVariants::All,
         );
 
-        let filter = NodeFilter::name().is_not_in(vec!["".into()]);
+        let filter = NodeFilter::name().is_not_in(vec![""]);
         let expected_results = vec!["1", "2", "3", "4"];
         assert_filter_nodes_results(
             init_nodes_graph,
@@ -1865,7 +1869,7 @@ mod test_node_filter {
 
     #[test]
     fn test_filter_nodes_for_node_type_in() {
-        let filter = NodeFilter::node_type().is_in(vec!["fire_nation".into()]);
+        let filter = NodeFilter::node_type().is_in(vec!["fire_nation"]);
         let expected_results = vec!["1", "3"];
         assert_filter_nodes_results(
             init_nodes_graph,
@@ -1882,7 +1886,7 @@ mod test_node_filter {
             TestVariants::All,
         );
 
-        let filter = NodeFilter::node_type().is_in(vec!["fire_nation".into(), "air_nomads".into()]);
+        let filter = NodeFilter::node_type().is_in(vec!["fire_nation", "air_nomads"]);
         let expected_results = vec!["1", "2", "3"];
         assert_filter_nodes_results(
             init_nodes_graph,
@@ -1902,7 +1906,7 @@ mod test_node_filter {
 
     #[test]
     fn test_filter_nodes_for_node_type_not_in() {
-        let filter = NodeFilter::node_type().is_not_in(vec!["fire_nation".into()]);
+        let filter = NodeFilter::node_type().is_not_in(vec!["fire_nation"]);
         let expected_results = vec!["2", "4"];
         assert_filter_nodes_results(
             init_nodes_graph,
@@ -2069,9 +2073,7 @@ mod test_node_filter {
 
     #[test]
     fn test_filter_nodes_for_not_node_type() {
-        let filter = NodeFilter::node_type()
-            .is_not_in(vec!["fire_nation".into()])
-            .not();
+        let filter = NodeFilter::node_type().is_not_in(vec!["fire_nation"]).not();
         let expected_results = vec!["1", "3"];
         assert_filter_nodes_results(
             init_nodes_graph,
@@ -2475,13 +2477,20 @@ mod test_node_filter {
     #[test]
     fn test_filter_by_column() {
         let graph = Graph::new();
-        graph.add_node(1, 1, NO_PROPS, None).unwrap();
-        graph.add_node(1, 2, NO_PROPS, None).unwrap();
-        graph.add_node(1, 3, NO_PROPS, None).unwrap();
-        graph.add_node(1, 4, NO_PROPS, None).unwrap();
-        graph.add_node(1, 5, NO_PROPS, None).unwrap();
+        graph.add_node(1, 1, NO_PROPS, None, None).unwrap();
+        graph.add_node(1, 2, NO_PROPS, None, None).unwrap();
+        graph.add_node(1, 3, NO_PROPS, None, None).unwrap();
+        graph.add_node(1, 4, NO_PROPS, None, None).unwrap();
+        graph.add_node(1, 5, NO_PROPS, None, None).unwrap();
 
         let mask = alternating_mask(&graph);
+        let expected_nodes: Vec<_> = graph
+            .nodes()
+            .name()
+            .iter_values()
+            .skip(1)
+            .step_by(2)
+            .collect();
 
         let filtered = graph
             .filter(NodeFilter::by_column(&mask, "bool_col").unwrap())
@@ -2493,7 +2502,7 @@ mod test_node_filter {
             .map(|n| n.id().to_string())
             .collect::<Vec<_>>();
 
-        assert_eq!(names, vec!["2", "4"]);
+        assert_eq!(names, expected_nodes);
 
         let filtered = graph
             .nodes()
@@ -2505,7 +2514,7 @@ mod test_node_filter {
             .map(|n| n.id().to_string())
             .collect::<Vec<_>>();
 
-        assert_eq!(names, vec!["2", "4"]);
+        assert_eq!(names, expected_nodes);
     }
 
     #[test]
@@ -5044,7 +5053,7 @@ mod test_node_property_filter_agg {
             graph::{
                 assertions::{
                     assert_filter_nodes_err, assert_filter_nodes_results,
-                    assert_search_nodes_results, TestVariants::NonDiskOnly,
+                    assert_search_nodes_results, TestVariants::All,
                 },
                 views::filter::{
                     model::{
@@ -5065,44 +5074,41 @@ mod test_node_property_filter_agg {
     use raphtory_storage::mutation::{
         addition_ops::InternalAdditionOps, property_addition_ops::InternalPropertyAdditionOps,
     };
-    use std::{sync::Arc, vec};
 
     fn list_u8(xs: &[u8]) -> Prop {
-        Prop::List(Arc::new(xs.iter().copied().map(Prop::U8).collect()))
+        Prop::list(xs.iter().copied().map(Prop::U8))
     }
     fn list_u16(xs: &[u16]) -> Prop {
-        Prop::List(Arc::new(xs.iter().copied().map(Prop::U16).collect()))
+        Prop::list(xs.iter().copied().map(Prop::U16))
     }
     fn list_u32(xs: &[u32]) -> Prop {
-        Prop::List(Arc::new(xs.iter().copied().map(Prop::U32).collect()))
+        Prop::list(xs.iter().copied().map(Prop::U32))
     }
     fn list_u64(xs: &[u64]) -> Prop {
-        Prop::List(Arc::new(xs.iter().copied().map(Prop::U64).collect()))
+        Prop::list(xs.iter().copied().map(Prop::U64))
     }
     fn list_i32(xs: &[i32]) -> Prop {
-        Prop::List(Arc::new(xs.iter().copied().map(Prop::I32).collect()))
+        Prop::list(xs.iter().copied().map(Prop::I32))
     }
     fn list_i64(xs: &[i64]) -> Prop {
-        Prop::List(Arc::new(xs.iter().copied().map(Prop::I64).collect()))
+        Prop::list(xs.iter().copied().map(Prop::I64))
     }
     fn list_f32(xs: &[f32]) -> Prop {
-        Prop::List(Arc::new(xs.iter().copied().map(Prop::F32).collect()))
+        Prop::list(xs.iter().copied().map(Prop::F32))
     }
     fn list_f64(xs: &[f64]) -> Prop {
-        Prop::List(Arc::new(xs.iter().copied().map(Prop::F64).collect()))
+        Prop::list(xs.iter().copied().map(Prop::F64))
     }
     fn list_str(xs: &[&str]) -> Prop {
-        Prop::List(Arc::new(
-            xs.iter().map(|s| Prop::Str(ArcStr::from(*s))).collect(),
-        ))
+        Prop::list(xs.iter().map(|s| Prop::Str(ArcStr::from(*s))))
     }
     fn list_bool(xs: &[bool]) -> Prop {
-        Prop::List(Arc::new(xs.iter().copied().map(Prop::Bool).collect()))
+        Prop::list(xs.iter().copied().map(Prop::Bool))
     }
 
     #[inline]
     fn list(v: Vec<Prop>) -> Prop {
-        Prop::List(Arc::new(v))
+        Prop::List(v.into())
     }
 
     pub fn init_nodes_graph<
@@ -5311,7 +5317,7 @@ mod test_node_property_filter_agg {
         ];
 
         for (t, id, props) in nodes {
-            graph.add_node(t, id, props, None).unwrap();
+            graph.add_node(t, id, props, None, None).unwrap();
         }
 
         let metadata: [(&str, Vec<(&str, Prop)>); 8] = [
@@ -5388,7 +5394,7 @@ mod test_node_property_filter_agg {
             IdentityGraphTransformer,
             filter.clone(),
             &expected,
-            NonDiskOnly,
+            All,
         );
 
         assert_search_nodes_results(
@@ -5396,7 +5402,7 @@ mod test_node_property_filter_agg {
             IdentityGraphTransformer,
             filter,
             &expected,
-            NonDiskOnly,
+            All,
         );
     }
 
@@ -5409,7 +5415,7 @@ mod test_node_property_filter_agg {
             IdentityGraphTransformer,
             filter.clone(),
             &expected,
-            NonDiskOnly,
+            All,
         );
 
         // assert_search_nodes_err(
@@ -5417,7 +5423,7 @@ mod test_node_property_filter_agg {
         //     IdentityGraphTransformer,
         //     filter,
         //     expected,
-        //     NonDiskOnly,
+        //     All,
         // );
     }
 
@@ -8702,7 +8708,7 @@ mod test_edge_filter {
 
     #[test]
     fn test_filter_edges_for_src_in() {
-        let filter = EdgeFilter::src().name().is_in(vec!["1".into()]);
+        let filter = EdgeFilter::src().name().is_in(vec!["1"]);
         let expected_results = vec!["1->2"];
         assert_filter_edges_results(
             init_edges_graph,
@@ -8719,7 +8725,7 @@ mod test_edge_filter {
             TestVariants::All,
         );
 
-        let filter = EdgeFilter::src().name().is_in(vec!["1".into(), "2".into()]);
+        let filter = EdgeFilter::src().name().is_in(vec!["1", "2"]);
         let expected_results = vec!["1->2", "2->1", "2->3"];
         assert_filter_edges_results(
             init_edges_graph,
@@ -8739,7 +8745,7 @@ mod test_edge_filter {
 
     #[test]
     fn test_filter_edges_for_src_not_in() {
-        let filter = EdgeFilter::src().name().is_not_in(vec!["1".into()]);
+        let filter = EdgeFilter::src().name().is_not_in(vec!["1"]);
         let expected_results = vec![
             "2->1",
             "2->3",
@@ -8811,7 +8817,7 @@ mod test_edge_filter {
 
     #[test]
     fn test_filter_edges_for_dst_in() {
-        let filter = EdgeFilter::dst().name().is_in(vec!["2".into()]);
+        let filter = EdgeFilter::dst().name().is_in(vec!["2"]);
         let expected_results = vec!["1->2"];
         assert_filter_edges_results(
             init_edges_graph,
@@ -8828,7 +8834,7 @@ mod test_edge_filter {
             TestVariants::All,
         );
 
-        let filter = EdgeFilter::dst().name().is_in(vec!["2".into(), "3".into()]);
+        let filter = EdgeFilter::dst().name().is_in(vec!["2", "3"]);
         let expected_results = vec!["1->2", "2->3"];
         assert_filter_edges_results(
             init_edges_graph,
@@ -8848,7 +8854,7 @@ mod test_edge_filter {
 
     #[test]
     fn test_filter_edges_for_dst_not_in() {
-        let filter = EdgeFilter::dst().name().is_not_in(vec!["1".into()]);
+        let filter = EdgeFilter::dst().name().is_not_in(vec!["1"]);
         let expected_results = vec![
             "1->2",
             "2->3",
@@ -9089,7 +9095,7 @@ mod test_edge_filter {
 
     #[test]
     fn test_filter_edges_for_not_src() {
-        let filter = EdgeFilter::src().name().is_not_in(vec!["1".into()]).not();
+        let filter = EdgeFilter::src().name().is_not_in(vec!["1"]).not();
         let expected_results = vec!["1->2"];
         assert_filter_edges_results(
             init_edges_graph,
@@ -9954,21 +9960,21 @@ mod test_edge_filter {
             IdentityGraphTransformer,
             filter.clone(),
             &expected_results,
-            TestVariants::NonDiskOnly,
+            TestVariants::All,
         );
         assert_select_edges_results(
             init_edges_graph_with_str_ids_del,
             IdentityGraphTransformer,
             filter.clone(),
             &expected_results,
-            TestVariants::NonDiskOnly,
+            TestVariants::All,
         );
         assert_search_edges_results(
             init_edges_graph_with_str_ids_del,
             IdentityGraphTransformer,
             filter.clone(),
             &expected_results,
-            TestVariants::NonDiskOnly,
+            TestVariants::All,
         );
     }
 
@@ -9982,21 +9988,21 @@ mod test_edge_filter {
             IdentityGraphTransformer,
             filter.clone(),
             &expected_results,
-            TestVariants::NonDiskOnly,
+            TestVariants::All,
         );
         assert_select_edges_results(
             init_edges_graph_with_str_ids_del,
             IdentityGraphTransformer,
             filter.clone(),
             &expected_results,
-            TestVariants::NonDiskOnly,
+            TestVariants::All,
         );
         assert_search_edges_results(
             init_edges_graph_with_str_ids_del,
             IdentityGraphTransformer,
             filter.clone(),
             &expected_results,
-            TestVariants::NonDiskOnly,
+            TestVariants::All,
         );
     }
 
@@ -12003,7 +12009,7 @@ mod test_edge_composite_filter {
             IdentityGraphTransformer,
             filter.clone(),
             &expected_results,
-            TestVariants::NonDiskOnly,
+            TestVariants::All,
         );
         let filter = filter.try_as_composite_edge_filter().unwrap();
         assert_filter_edges_results(
@@ -12018,7 +12024,7 @@ mod test_edge_composite_filter {
             IdentityGraphTransformer,
             filter.clone(),
             &expected_results,
-            TestVariants::NonDiskOnly,
+            TestVariants::All,
         );
 
         let filter = EdgeFilter
@@ -12038,7 +12044,7 @@ mod test_edge_composite_filter {
             IdentityGraphTransformer,
             filter.clone(),
             &expected_results,
-            TestVariants::NonDiskOnly,
+            TestVariants::All,
         );
         let filter = filter.try_as_composite_edge_filter().unwrap();
         assert_filter_edges_results(
@@ -12053,7 +12059,7 @@ mod test_edge_composite_filter {
             IdentityGraphTransformer,
             filter.clone(),
             &expected_results,
-            TestVariants::NonDiskOnly,
+            TestVariants::All,
         );
 
         let filter = EdgeFilter.property("p1").eq("pometry").or(EdgeFilter
@@ -12078,7 +12084,7 @@ mod test_edge_composite_filter {
             IdentityGraphTransformer,
             filter.clone(),
             &expected_results,
-            TestVariants::NonDiskOnly,
+            TestVariants::All,
         );
         let filter = filter.try_as_composite_edge_filter().unwrap();
         assert_filter_edges_results(
@@ -12093,7 +12099,7 @@ mod test_edge_composite_filter {
             IdentityGraphTransformer,
             filter.clone(),
             &expected_results,
-            TestVariants::NonDiskOnly,
+            TestVariants::All,
         );
 
         let filter = EdgeFilter::src()
@@ -12113,7 +12119,7 @@ mod test_edge_composite_filter {
             IdentityGraphTransformer,
             filter.clone(),
             &expected_results,
-            TestVariants::NonDiskOnly,
+            TestVariants::All,
         );
         let filter = filter.try_as_composite_edge_filter().unwrap();
         assert_filter_edges_results(
@@ -12128,7 +12134,7 @@ mod test_edge_composite_filter {
             IdentityGraphTransformer,
             filter.clone(),
             &expected_results,
-            TestVariants::NonDiskOnly,
+            TestVariants::All,
         );
 
         let filter = EdgeFilter
@@ -12148,7 +12154,7 @@ mod test_edge_composite_filter {
             IdentityGraphTransformer,
             filter.clone(),
             &expected_results,
-            TestVariants::NonDiskOnly,
+            TestVariants::All,
         );
         let filter = filter.try_as_composite_edge_filter().unwrap();
         assert_filter_edges_results(
@@ -12163,7 +12169,7 @@ mod test_edge_composite_filter {
             IdentityGraphTransformer,
             filter.clone(),
             &expected_results,
-            TestVariants::NonDiskOnly,
+            TestVariants::All,
         );
 
         let filter = EdgeFilter::src()
@@ -12183,7 +12189,7 @@ mod test_edge_composite_filter {
             IdentityGraphTransformer,
             filter.clone(),
             &expected_results,
-            TestVariants::NonDiskOnly,
+            TestVariants::All,
         );
         let filter = filter.try_as_composite_edge_filter().unwrap();
         assert_filter_edges_results(
@@ -12198,7 +12204,7 @@ mod test_edge_composite_filter {
             IdentityGraphTransformer,
             filter.clone(),
             &expected_results,
-            TestVariants::NonDiskOnly,
+            TestVariants::All,
         );
 
         let filter = EdgeFilter::dst()
@@ -12254,7 +12260,7 @@ mod test_edge_composite_filter {
             IdentityGraphTransformer,
             filter.clone(),
             &expected_results,
-            TestVariants::NonDiskOnly,
+            TestVariants::All,
         );
 
         let filter = filter.try_as_composite_edge_filter().unwrap();
@@ -12270,7 +12276,7 @@ mod test_edge_composite_filter {
             IdentityGraphTransformer,
             filter.clone(),
             &expected_results,
-            TestVariants::NonDiskOnly,
+            TestVariants::All,
         );
     }
 
diff --git a/raphtory/tests/test_history.rs b/raphtory/tests/test_history.rs
index fb394bae36..2a9d00fdae 100644
--- a/raphtory/tests/test_history.rs
+++ b/raphtory/tests/test_history.rs
@@ -12,12 +12,12 @@ use std::error::Error;
 #[test]
 fn test_neighbours_history() -> Result<(), Box<dyn Error>> {
     let graph = Graph::new();
-    let node = graph.add_node(1, "node", NO_PROPS, None).unwrap();
-    let node2 = graph.add_node(2, "node2", NO_PROPS, None).unwrap();
-    let node3 = graph.add_node(3, "node3", NO_PROPS, None).unwrap();
+    let node = graph.add_node(1, "node", NO_PROPS, None, None).unwrap();
+    let node2 = graph.add_node(2, "node2", NO_PROPS, None, None).unwrap();
+    let node3 = graph.add_node(3, "node3", NO_PROPS, None, None).unwrap();
     let _edge = graph.add_edge(4, &node, &node2, NO_PROPS, None).unwrap();
     let _edge2 = graph.add_edge(5, &node, &node3, NO_PROPS, None).unwrap();
-    let node4 = graph.add_node(6, "node4", NO_PROPS, None).unwrap();
+    let node4 = graph.add_node(6, "node4", NO_PROPS, None, None).unwrap();
     let _edge3 = graph.add_edge(7, &node2, &node4, NO_PROPS, None).unwrap();
 
     let history = graph.node("node").unwrap().neighbours().combined_history();
@@ -37,15 +37,15 @@ fn test_neighbours_history() -> Result<(), Box<dyn Error>> {
 #[test]
 fn test_intervals() -> Result<(), Box<dyn Error>> {
     let graph = Graph::new();
-    let node = graph.add_node(1, "node", NO_PROPS, None).unwrap();
-    graph.add_node(4, "node", NO_PROPS, None).unwrap();
-    graph.add_node(10, "node", NO_PROPS, None).unwrap();
-    graph.add_node(30, "node", NO_PROPS, None).unwrap();
+    let node = graph.add_node(1, "node", NO_PROPS, None, None).unwrap();
+    graph.add_node(4, "node", NO_PROPS, None, None).unwrap();
+    graph.add_node(10, "node", NO_PROPS, None, None).unwrap();
+    graph.add_node(30, "node", NO_PROPS, None, None).unwrap();
     let interval = Intervals(&node);
     assert_eq!(interval.collect(), &[3, 6, 20]);
 
     // make sure there are no intervals (1 time entry)
-    let node2 = graph.add_node(1, "node2", NO_PROPS, None).unwrap();
+    let node2 = graph.add_node(1, "node2", NO_PROPS, None, None).unwrap();
     let interval2 = Intervals(&node2);
     assert_eq!(interval2.collect(), Vec::<i64>::new());
     Ok(())
@@ -54,12 +54,12 @@ fn test_intervals() -> Result<(), Box<dyn Error>> {
 #[test]
 fn test_intervals_same_timestamp() -> Result<(), Box<dyn Error>> {
     let graph = Graph::new();
-    let node = graph.add_node(1, "node", NO_PROPS, None).unwrap();
-    graph.add_node(1, "node", NO_PROPS, None).unwrap();
+    let node = graph.add_node(1, "node", NO_PROPS, None, None).unwrap();
+    graph.add_node(1, "node", NO_PROPS, None, None).unwrap();
     let interval = Intervals(&node);
     assert_eq!(interval.collect(), &[0]);
 
-    graph.add_node(2, "node", NO_PROPS, None).unwrap();
+    graph.add_node(2, "node", NO_PROPS, None, None).unwrap();
     assert_eq!(interval.collect(), &[0, 1]);
     Ok(())
 }
@@ -67,15 +67,15 @@ fn test_intervals_same_timestamp() -> Result<(), Box<dyn Error>> {
 #[test]
 fn test_intervals_mean() -> Result<(), Box<dyn Error>> {
     let graph = Graph::new();
-    let node = graph.add_node(1, "node", NO_PROPS, None).unwrap();
-    graph.add_node(4, "node", NO_PROPS, None).unwrap();
-    graph.add_node(10, "node", NO_PROPS, None).unwrap();
-    graph.add_node(30, "node", NO_PROPS, None).unwrap();
+    let node = graph.add_node(1, "node", NO_PROPS, None, None).unwrap();
+    graph.add_node(4, "node", NO_PROPS, None, None).unwrap();
+    graph.add_node(10, "node", NO_PROPS, None, None).unwrap();
+    graph.add_node(30, "node", NO_PROPS, None, None).unwrap();
     let interval = Intervals(&node);
     assert_eq!(interval.mean(), Some(29f64 / 3f64));
 
     // make sure mean is None if there is no interval to be calculated (1 time entry)
-    let node2 = graph.add_node(1, "node2", NO_PROPS, None).unwrap();
+    let node2 = graph.add_node(1, "node2", NO_PROPS, None, None).unwrap();
     let interval2 = Intervals(&node2);
     assert_eq!(interval2.mean(), None);
     Ok(())
@@ -84,15 +84,15 @@ fn test_intervals_mean() -> Result<(), Box<dyn Error>> {
 #[test]
 fn test_intervals_median() -> Result<(), Box<dyn Error>> {
     let graph = Graph::new();
-    let node = graph.add_node(1, "node", NO_PROPS, None).unwrap();
-    graph.add_node(30, "node", NO_PROPS, None).unwrap();
-    graph.add_node(31, "node", NO_PROPS, None).unwrap();
-    graph.add_node(40, "node", NO_PROPS, None).unwrap(); // intervals are 29, 1, 9
+    let node = graph.add_node(1, "node", NO_PROPS, None, None).unwrap();
+    graph.add_node(30, "node", NO_PROPS, None, None).unwrap();
+    graph.add_node(31, "node", NO_PROPS, None, None).unwrap();
+    graph.add_node(40, "node", NO_PROPS, None, None).unwrap(); // intervals are 29, 1, 9
     let interval = Intervals(&node);
     assert_eq!(interval.median(), Some(9));
 
     // make sure median is None if there is no interval to be calculated (1 time entry)
-    let node2 = graph.add_node(1, "node2", NO_PROPS, None).unwrap();
+    let node2 = graph.add_node(1, "node2", NO_PROPS, None, None).unwrap();
     let interval2 = Intervals(&node2);
     assert_eq!(interval2.median(), None);
     Ok(())
@@ -101,15 +101,15 @@ fn test_intervals_median() -> Result<(), Box<dyn Error>> {
 #[test]
 fn test_intervals_max() -> Result<(), Box<dyn Error>> {
     let graph = Graph::new();
-    let node = graph.add_node(1, "node", NO_PROPS, None).unwrap();
-    graph.add_node(30, "node", NO_PROPS, None).unwrap();
-    graph.add_node(31, "node", NO_PROPS, None).unwrap();
-    graph.add_node(40, "node", NO_PROPS, None).unwrap(); // intervals are 29, 1, 9
+    let node = graph.add_node(1, "node", NO_PROPS, None, None).unwrap();
+    graph.add_node(30, "node", NO_PROPS, None, None).unwrap();
+    graph.add_node(31, "node", NO_PROPS, None, None).unwrap();
+    graph.add_node(40, "node", NO_PROPS, None, None).unwrap(); // intervals are 29, 1, 9
     let interval = Intervals(&node);
     assert_eq!(interval.max(), Some(29));
 
     // make sure max is None if there is no interval to be calculated (1 time entry)
-    let node2 = graph.add_node(1, "node2", NO_PROPS, None).unwrap();
+    let node2 = graph.add_node(1, "node2", NO_PROPS, None, None).unwrap();
     let interval2 = Intervals(&node2);
     assert_eq!(interval2.max(), None);
     Ok(())
@@ -120,11 +120,17 @@ fn test_intervals_max() -> Result<(), Box<dyn Error>> {
 fn test_basic() -> Result<(), Box<dyn Error>> {
     let graph = Graph::new();
     let dumbledore_node = graph
-        .add_node(1, "Dumbledore", [("type", Prop::str("Character"))], None)
+        .add_node(
+            1,
+            "Dumbledore",
+            [("type", Prop::str("Character"))],
+            None,
+            None,
+        )
         .unwrap();
 
     let harry_node = graph
-        .add_node(2, "Harry", [("type", Prop::str("Character"))], None)
+        .add_node(2, "Harry", [("type", Prop::str("Character"))], None, None)
         .unwrap();
 
     let character_edge = graph
@@ -180,12 +186,18 @@ fn test_basic() -> Result<(), Box<dyn Error>> {
 fn test_single_layer() -> Result<(), Box<dyn Error>> {
     let graph = Graph::new();
     let dumbledore_node = graph
-        .add_node(1, "Dumbledore", [("type", Prop::str("Character"))], None)
+        .add_node(
+            1,
+            "Dumbledore",
+            [("type", Prop::str("Character"))],
+            None,
+            None,
+        )
         .unwrap();
     let dumbledore_node_id = dumbledore_node.id();
 
     let harry_node = graph
-        .add_node(2, "Harry", [("type", Prop::str("Character"))], None)
+        .add_node(2, "Harry", [("type", Prop::str("Character"))], None, None)
         .unwrap();
     let harry_node_id = harry_node.id();
 
@@ -200,7 +212,13 @@ fn test_single_layer() -> Result<(), Box<dyn Error>> {
         .unwrap();
 
     let broom_node = graph
-        .add_node(4, "Broom", [("type", Prop::str("Magical Object"))], None)
+        .add_node(
+            4,
+            "Broom",
+            [("type", Prop::str("Magical Object"))],
+            None,
+            None,
+        )
         .unwrap();
     let broom_node_id = broom_node.id();
 
@@ -339,11 +357,17 @@ fn test_single_layer() -> Result<(), Box<dyn Error>> {
 fn test_lazy_node_state() -> Result<(), Box<dyn Error>> {
     let graph = Graph::new();
     let _dumbledore_node = graph
-        .add_node(1, "Dumbledore", [("type", Prop::str("Character"))], None)
+        .add_node(
+            1,
+            "Dumbledore",
+            [("type", Prop::str("Character"))],
+            None,
+            None,
+        )
         .unwrap();
 
     let _harry_node = graph
-        .add_node(2, "Harry", [("type", Prop::str("Character"))], None)
+        .add_node(2, "Harry", [("type", Prop::str("Character"))], None, None)
         .unwrap();
 
     let _character_edge = graph
@@ -357,7 +381,13 @@ fn test_lazy_node_state() -> Result<(), Box<dyn Error>> {
         .unwrap();
 
     let _broom_node = graph
-        .add_node(4, "Broom", [("type", Prop::str("Magical Object"))], None)
+        .add_node(
+            4,
+            "Broom",
+            [("type", Prop::str("Magical Object"))],
+            None,
+            None,
+        )
         .unwrap();
 
     let _broom_harry_magical_edge = graph
@@ -422,21 +452,7 @@ fn test_lazy_node_state() -> Result<(), Box<dyn Error>> {
     ];
 
     // lazy_node_state returns an iterator of history objects, not ordered
-    let expected_history_all_unordered = [
-        EventTime::new(1, 0),
-        EventTime::new(3, 2),
-        EventTime::new(4, 5),
-        EventTime::new(5, 7),
-        EventTime::new(2, 1),
-        EventTime::new(3, 2),
-        EventTime::new(4, 4),
-        EventTime::new(5, 6),
-        EventTime::new(4, 3),
-        EventTime::new(4, 4),
-        EventTime::new(4, 5),
-        EventTime::new(5, 6),
-        EventTime::new(5, 7),
-    ];
+    let expected_history_all_unordered = [vec![4, 4, 4, 5, 5], vec![1, 3, 4, 5], vec![2, 3, 4, 5]];
 
     // Test that the merged history contains all timestamps from all nodes
     // Each operation adds a timestamp, so we should have timestamps from node additions and edge additions
@@ -462,20 +478,25 @@ fn test_lazy_node_state() -> Result<(), Box<dyn Error>> {
     assert_eq!(individual_histories, nodes_history_as_history.collect());
 
     // Test timestamp conversion
-    let timestamps: Vec<_> = all_nodes_history
+    let timestamps: Vec<Vec<_>> = all_nodes_history
         .t()
-        .iter_values()
-        .flat_map(|ts| ts.collect())
+        .iter()
+        .sorted_by_key(|(n, _)| n.id())
+        .map(|(_, ts)| ts.collect())
         .collect();
     assert!(!timestamps.is_empty());
-    assert_eq!(timestamps, expected_history_all_unordered.map(|t| t.t()));
+    assert_eq!(timestamps, expected_history_all_unordered);
 
     // Test intervals
-    let intervals: Vec<_> = all_nodes_history.intervals().collect();
+    let intervals = all_nodes_history.intervals();
     assert_eq!(intervals.len(), 3); // One per node
     assert_eq!(
-        intervals.iter().map(|i| i.collect()).collect::<Vec<_>>(),
-        vec!(vec![2, 1, 1], vec![1, 1, 1], vec![0, 0, 1, 0])
+        intervals
+            .iter()
+            .sorted_by_key(|(n, _)| n.id())
+            .map(|(_, i)| i.collect())
+            .collect::<Vec<_>>(),
+        vec!(vec![0, 0, 1, 0], vec![2, 1, 1], vec![1, 1, 1])
     );
 
     // Test windowed operations
@@ -544,22 +565,27 @@ fn test_lazy_node_state() -> Result<(), Box<dyn Error>> {
     // These return LazyNodeState with different operations
     assert_eq!(
         earliest_times
-            .iter_values()
-            .map(|t| t.unwrap())
+            .iter()
+            .sorted_by_key(|(n, _)| n.id())
+            .map(|(_, t)| t.unwrap())
             .collect_vec(),
         [
+            EventTime::new(4, 3),
             EventTime::new(1, 0),
-            EventTime::new(2, 1),
-            EventTime::new(4, 3)
+            EventTime::new(2, 1)
         ]
     );
 
     assert_eq!(
-        latest_times.iter_values().map(|t| t.unwrap()).collect_vec(),
+        latest_times
+            .iter()
+            .sorted_by_key(|(n, _)| n.id())
+            .map(|(_, t)| t.unwrap())
+            .collect_vec(),
         [
             EventTime::new(5, 7),
-            EventTime::new(5, 6),
-            EventTime::new(5, 7)
+            EventTime::new(5, 7),
+            EventTime::new(5, 6)
         ]
     );
 
@@ -575,11 +601,12 @@ fn test_lazy_node_state() -> Result<(), Box<dyn Error>> {
     // Test event id access
     let event_ids_lazy: Vec<_> = all_nodes_history
         .event_id()
-        .iter_values()
-        .flat_map(|s| s.collect())
+        .iter()
+        .sorted_by_key(|(n, _)| n.id())
+        .flat_map(|(_, s)| s.collect())
         .collect();
     let event_ids_normal: Vec<_> = nodes_history_as_history.event_id().collect();
-    assert_eq!(event_ids_lazy, [0, 2, 5, 7, 1, 2, 4, 6, 3, 4, 5, 6, 7]); // unordered
+    assert_eq!(event_ids_lazy, [3, 4, 5, 6, 7, 0, 2, 5, 7, 1, 2, 4, 6,]); // unordered
     assert_eq!(event_ids_normal, [0, 1, 2, 2, 3, 4, 4, 5, 5, 6, 6, 7, 7]); // ordered
 
     // Test combined window and layer filtering
diff --git a/raphtory/tests/test_layers.rs b/raphtory/tests/test_layers.rs
index b73b15e693..880b96f8cb 100644
--- a/raphtory/tests/test_layers.rs
+++ b/raphtory/tests/test_layers.rs
@@ -4,13 +4,14 @@ use raphtory::{
     db::graph::{graph::assert_graph_equal, views::deletion_graph::PersistentGraph},
     prelude::*,
     test_storage,
-    test_utils::{build_graph, build_graph_layer, build_graph_strat},
+    test_utils::{build_graph, build_graph_layer, build_graph_strat, GraphFixture},
 };
 use raphtory_api::core::entities::GID;
+use serde_json::json;
 
 #[test]
 fn prop_test_layering() {
-    proptest!(|(graph_f in build_graph_strat(10, 10, false), layer in proptest::sample::subsequence(&["_default", "a", "b"], 0..3))| {
+    proptest!(|(graph_f in build_graph_strat(10, 10, 10, 10, false), layer in proptest::sample::subsequence(&["_default", "a", "b"], 0..3))| {
         let g_layer_expected = Graph::from(build_graph_layer(&graph_f, &layer));
         let g = Graph::from(build_graph(&graph_f));
             let g_layer = g.valid_layers(layer.clone());
@@ -18,9 +19,53 @@ fn prop_test_layering() {
     })
 }
 
+#[test]
+fn test_node_explicit_node_additions() {
+    let graph_f: GraphFixture = serde_json::from_value(json!({"nodes":{"10":{"props":{"t_props":[[0,[]]],"c_props":[]},"node_type":null}},"edges":[]})).unwrap();
+    let layer = [];
+    let g_layer_expected = Graph::from(build_graph_layer(&graph_f, &layer));
+    let g = Graph::from(build_graph(&graph_f));
+    let g_layer = g.valid_layers(layer.clone());
+
+    assert_graph_equal(&g_layer, &g_layer_expected);
+}
+
+#[test]
+fn test_failure() {
+    let graph_f: GraphFixture = serde_json::from_value(json!({"nodes":{},"edges":[[[0,0,"a"],{"props":{"t_props":[[0,[]]],"c_props":[]},"deletions":[]}],[[3,9,"b"],{"props":{"t_props":[[0,[]]],"c_props":[]},"deletions":[]}],[[9,3,"b"],{"props":{"t_props":[[0,[]]],"c_props":[]},"deletions":[]}],[[0,0,null],{"props":{"t_props":[[0,[]]],"c_props":[]},"deletions":[]}]]})).unwrap();
+    let layer = ["_default", "b"];
+    let g_layer_expected = Graph::from(build_graph_layer(&graph_f, &layer));
+    let g = Graph::from(build_graph(&graph_f));
+    let g_layer = g.valid_layers(layer.clone());
+
+    assert_graph_equal(&g_layer, &g_layer_expected);
+}
+
+#[test]
+fn test_failure2() {
+    let graph_f: GraphFixture = serde_json::from_value(json!({"nodes":{},"edges":[[[0,0,null],{"props":{"t_props":[[0,[]]],"c_props":[]},"deletions":[]}],[[0,0,"a"],{"props":{"t_props":[[0,[]]],"c_props":[]},"deletions":[]}],[[0,0,"b"],{"props":{"t_props":[[0,[]]],"c_props":[]},"deletions":[]}]]})).unwrap();
+    let layer = ["_default", "b"];
+    let g_layer_expected = Graph::from(build_graph_layer(&graph_f, &layer));
+    let g = Graph::from(build_graph(&graph_f));
+    let g_layer = g.valid_layers(layer.clone());
+
+    assert_graph_equal(&g_layer, &g_layer_expected);
+}
+
+#[test]
+fn test_failure3() {
+    let graph_f: GraphFixture = serde_json::from_value(json!({"nodes":{},"edges":[[[0,0,null],{"props":{"t_props":[[0,[]]],"c_props":[]},"deletions":[]}],[[0,0,"b"],{"props":{"t_props":[[0,[]]],"c_props":[]},"deletions":[]}],[[0,1,"a"],{"props":{"t_props":[[0,[]]],"c_props":[]},"deletions":[]}]]})).unwrap();
+    let layer = ["_default", "b"];
+    let g_layer_expected = Graph::from(build_graph_layer(&graph_f, &layer));
+    let g = Graph::from(build_graph(&graph_f));
+    let g_layer = g.valid_layers(layer.clone());
+
+    assert_graph_equal(&g_layer, &g_layer_expected);
+}
+
 #[test]
 fn prop_test_layering_persistent_graph() {
-    proptest!(|(graph_f in build_graph_strat(10, 10, true), layer in proptest::sample::subsequence(&["_default", "a", "b"], 0..3))| {
+    proptest!(|(graph_f in build_graph_strat(10, 10, 10, 10, true), layer in proptest::sample::subsequence(&["_default", "a", "b"], 0..3))| {
         let g_layer_expected = PersistentGraph::from(build_graph_layer(&graph_f, &layer));
         let g = PersistentGraph::from(build_graph(&graph_f));
         let g_layer = g.valid_layers(layer);
@@ -236,7 +281,9 @@ pub mod test_filters_layer_graph {
             ];
 
             for (id, name, props, label) in &nodes {
-                graph.add_node(*id, name, props.clone(), *label).unwrap();
+                graph
+                    .add_node(*id, name, props.clone(), *label, None)
+                    .unwrap();
             }
 
             graph
diff --git a/raphtory/tests/test_materialize.rs b/raphtory/tests/test_materialize.rs
index dac5b88465..77a20b62b9 100644
--- a/raphtory/tests/test_materialize.rs
+++ b/raphtory/tests/test_materialize.rs
@@ -1,3 +1,4 @@
+use itertools::Itertools;
 use proptest::{arbitrary::any, proptest};
 use raphtory::{
     db::graph::graph::{assert_graph_equal, assert_graph_equal_timestamps},
@@ -33,6 +34,7 @@ fn test_materialize() {
         .get("layer1")
         .and_then(|prop| prop.latest())
         .is_none());
+
     assert!(gm
         .into_events()
         .unwrap()
@@ -76,11 +78,11 @@ fn materialize_prop_test() {
 #[test]
 fn test_subgraph() {
     let g = Graph::new();
-    g.add_node(0, 1, NO_PROPS, None).unwrap();
-    g.add_node(0, 2, NO_PROPS, None).unwrap();
-    g.add_node(0, 3, NO_PROPS, None).unwrap();
-    g.add_node(0, 4, NO_PROPS, None).unwrap();
-    g.add_node(0, 5, NO_PROPS, None).unwrap();
+    g.add_node(0, 1, NO_PROPS, None, None).unwrap();
+    g.add_node(0, 2, NO_PROPS, None, None).unwrap();
+    g.add_node(0, 3, NO_PROPS, None, None).unwrap();
+    g.add_node(0, 4, NO_PROPS, None, None).unwrap();
+    g.add_node(0, 5, NO_PROPS, None, None).unwrap();
 
     let nodes_subgraph = g.subgraph(vec![4, 5]);
     assert_eq!(
@@ -98,11 +100,11 @@ fn test_subgraph() {
 #[test]
 fn test_exclude_nodes() {
     let g = Graph::new();
-    g.add_node(0, 1, NO_PROPS, None).unwrap();
-    g.add_node(0, 2, NO_PROPS, None).unwrap();
-    g.add_node(0, 3, NO_PROPS, None).unwrap();
-    g.add_node(0, 4, NO_PROPS, None).unwrap();
-    g.add_node(0, 5, NO_PROPS, None).unwrap();
+    g.add_node(0, 1, NO_PROPS, None, None).unwrap();
+    g.add_node(0, 2, NO_PROPS, None, None).unwrap();
+    g.add_node(0, 3, NO_PROPS, None, None).unwrap();
+    g.add_node(0, 4, NO_PROPS, None, None).unwrap();
+    g.add_node(0, 5, NO_PROPS, None, None).unwrap();
 
     let exclude_nodes_subgraph = g.exclude_nodes(vec![4, 5]);
     assert_eq!(
@@ -110,6 +112,7 @@ fn test_exclude_nodes() {
             .nodes()
             .name()
             .iter_values()
+            .sorted()
             .collect::<Vec<String>>(),
         vec!["1", "2", "3"]
     );
@@ -120,8 +123,8 @@ fn test_exclude_nodes() {
 #[test]
 fn testing_node_types() {
     let graph = Graph::new();
-    graph.add_node(0, "A", NO_PROPS, None).unwrap();
-    graph.add_node(1, "B", NO_PROPS, Some("H")).unwrap();
+    graph.add_node(0, "A", NO_PROPS, None, None).unwrap();
+    graph.add_node(1, "B", NO_PROPS, Some("H"), None).unwrap();
 
     test_storage!(&graph, |graph| {
         let node_a = graph.node("A").unwrap();
@@ -134,11 +137,15 @@ fn testing_node_types() {
     });
 
     // Nodes with No type can be overwritten
-    let node_a = graph.add_node(1, "A", NO_PROPS, Some("TYPEA")).unwrap();
+    let node_a = graph
+        .add_node(1, "A", NO_PROPS, Some("TYPEA"), None)
+        .unwrap();
     assert_eq!(node_a.node_type().as_str(), Some("TYPEA"));
 
     // Check that overwriting a node type returns an error
-    assert!(graph.add_node(2, "A", NO_PROPS, Some("TYPEB")).is_err());
+    assert!(graph
+        .add_node(2, "A", NO_PROPS, Some("TYPEB"), None)
+        .is_err());
     // Double check that the type did not actually change
     assert_eq!(graph.node("A").unwrap().node_type().as_str(), Some("TYPEA"));
     // Check that the update is not added to the graph
@@ -154,8 +161,8 @@ fn changing_property_type_errors() {
     g.add_properties(0, props_0.clone()).unwrap();
     assert!(g.add_properties(1, props_1.clone()).is_err());
 
-    g.add_node(0, 1, props_0.clone(), None).unwrap();
-    assert!(g.add_node(1, 1, props_1.clone(), None).is_err());
+    g.add_node(0, 1, props_0.clone(), None, None).unwrap();
+    assert!(g.add_node(1, 1, props_1.clone(), None, None).is_err());
 
     g.add_edge(0, 1, 2, props_0.clone(), None).unwrap();
     assert!(g.add_edge(1, 1, 2, props_1.clone(), None).is_err());
diff --git a/raphtory/tests/tests_node_type_filtered_subgraph.rs b/raphtory/tests/tests_node_type_filtered_subgraph.rs
index 5a0b58d743..63987402cb 100644
--- a/raphtory/tests/tests_node_type_filtered_subgraph.rs
+++ b/raphtory/tests/tests_node_type_filtered_subgraph.rs
@@ -39,7 +39,9 @@ fn test_type_filtered_subgraph() {
     ];
 
     for (id, name, props, layer) in &nodes {
-        graph.add_node(*id, name, props.clone(), *layer).unwrap();
+        graph
+            .add_node(*id, name, props.clone(), *layer, None)
+            .unwrap();
     }
 
     let filtered_graph = graph
@@ -65,7 +67,7 @@ fn test_type_filtered_subgraph() {
 
 #[test]
 fn materialize_prop_test() {
-    proptest!(|(graph_f in build_graph_strat(10, 10, true), node_types in make_node_types())| {
+    proptest!(|(graph_f in build_graph_strat(10, 10, 10, 10, true), node_types in make_node_types())| {
         let g = Graph::from(build_graph(&graph_f)).subgraph_node_types(node_types);
         let gm = g.materialize().unwrap();
         assert_graph_equal(&g, &gm);
@@ -74,7 +76,7 @@ fn materialize_prop_test() {
 
 #[test]
 fn materialize_type_window_prop_test() {
-    proptest!(|(graph_f in build_graph_strat(10, 10, true), w in any::<Range<i64>>(), node_types in make_node_types())| {
+    proptest!(|(graph_f in build_graph_strat(10, 10, 10, 10, true), w in any::<Range<i64>>(), node_types in make_node_types())| {
         let g = Graph::from(build_graph(&graph_f)).subgraph_node_types(node_types);
         let gvw = g.window(w.start, w.end);
         let gmw = gvw.materialize().unwrap();
@@ -84,7 +86,7 @@ fn materialize_type_window_prop_test() {
 
 #[test]
 fn materialize_window_type_prop_test() {
-    proptest!(|(graph_f in build_graph_strat(10, 10, true), w in any::<Range<i64>>(), node_types in make_node_types())| {
+    proptest!(|(graph_f in build_graph_strat(10, 10, 10, 10, true), w in any::<Range<i64>>(), node_types in make_node_types())| {
         let g = Graph::from(build_graph(&graph_f));
         let gvw = g.window(w.start, w.end).subgraph_node_types(node_types);
         let gmw = gvw.materialize().unwrap();
@@ -226,7 +228,9 @@ mod test_filters_node_type_filtered_subgraph {
 
             // Add nodes to the graph
             for (id, name, props, layer) in &nodes {
-                graph.add_node(*id, name, props.clone(), *layer).unwrap();
+                graph
+                    .add_node(*id, name, props.clone(), *layer, None)
+                    .unwrap();
             }
 
             graph
@@ -470,7 +474,9 @@ mod test_filters_node_type_filtered_subgraph {
             ];
 
             for (id, name, props, layer) in &nodes {
-                graph.add_node(*id, name, props.clone(), *layer).unwrap();
+                graph
+                    .add_node(*id, name, props.clone(), *layer, None)
+                    .unwrap();
             }
 
             graph
@@ -487,7 +493,7 @@ mod test_filters_node_type_filtered_subgraph {
                 },
                 views::filter::model::PropertyFilterFactory,
             },
-            prelude::{EdgeFilter, EdgeViewOps, GraphViewOps},
+            prelude::EdgeFilter,
         };
 
         #[test]
diff --git a/raphtory/tests/valid_graph.rs b/raphtory/tests/valid_graph.rs
index f4c94e4abe..3be0a1c862 100644
--- a/raphtory/tests/valid_graph.rs
+++ b/raphtory/tests/valid_graph.rs
@@ -47,7 +47,7 @@ fn test_valid_graph_events() -> Result<(), GraphError> {
 
 #[test]
 fn materialize_prop_test_persistent() {
-    proptest!(|(graph_f in build_graph_strat(10, 10, true))| {
+    proptest!(|(graph_f in build_graph_strat(10, 10, 10, 10, true))| {
         let g = PersistentGraph::from(build_graph(&graph_f)).valid();
         let gm = g.materialize().unwrap();
         assert_graph_equal(&g, &gm);
@@ -71,7 +71,7 @@ fn test_explode_layers() {
 
 #[test]
 fn materialize_prop_test_events() {
-    proptest!(|(graph_f in build_graph_strat(10, 10, true))| {
+    proptest!(|(graph_f in build_graph_strat(10, 10, 10, 10, true))| {
         let g = Graph::from(build_graph(&graph_f)).valid();
         let gm = g.materialize().unwrap();
         assert_graph_equal(&g, &gm);
@@ -112,7 +112,7 @@ fn test_single_deleted_edge_persistent() {
 
 #[test]
 fn materialize_valid_window_persistent_prop_test() {
-    proptest!(|(graph_f in build_graph_strat(10, 10, true), w in any::<Range<i64>>())| {
+    proptest!(|(graph_f in build_graph_strat(10, 10, 10, 10, true), w in any::<Range<i64>>())| {
         let g = PersistentGraph::from(build_graph(&graph_f));
         let gvw = g.valid().window(w.start, w.end);
         let gmw = gvw.materialize().unwrap();
@@ -132,7 +132,7 @@ fn test_deletions_in_window_but_edge_valid() {
 
 #[test]
 fn materialize_valid_window_events_prop_test() {
-    proptest!(|(graph_f in build_graph_strat(10, 10, true), w in any::<Range<i64>>())| {
+    proptest!(|(graph_f in build_graph_strat(10, 10, 10, 10, true), w in any::<Range<i64>>())| {
         let g = Graph::from(build_graph(&graph_f));
         let gvw = g.valid().window(w.start, w.end);
         let gmw = gvw.materialize().unwrap();
@@ -142,7 +142,7 @@ fn materialize_valid_window_events_prop_test() {
 
 #[test]
 fn materialize_window_valid_persistent_prop_test() {
-    proptest!(|(graph_f in build_graph_strat(10, 10, true), w in any::<Range<i64>>())| {
+    proptest!(|(graph_f in build_graph_strat(10, 10, 10, 10, true), w in any::<Range<i64>>())| {
         let g = PersistentGraph::from(build_graph(&graph_f));
         let gvw = g.window(w.start, w.end).valid();
         let gmw = gvw.materialize().unwrap();
@@ -152,7 +152,7 @@ fn materialize_window_valid_persistent_prop_test() {
 
 #[test]
 fn materialize_window_valid_events_prop_test() {
-    proptest!(|(graph_f in build_graph_strat(10, 10, true), w in any::<Range<i64>>())| {
+    proptest!(|(graph_f in build_graph_strat(10, 10, 10, 10, true), w in any::<Range<i64>>())| {
         let g = Graph::from(build_graph(&graph_f));
         let gvw = g.window(w.start, w.end).valid();
         let gmw = gvw.materialize().unwrap();
@@ -346,7 +346,8 @@ fn weird_empty_graph() {
 #[test]
 fn mismatched_node_earliest_time_again() {
     let g = PersistentGraph::new();
-    g.add_node(-2925244660385668056, 1, NO_PROPS, None).unwrap();
+    g.add_node(-2925244660385668056, 1, NO_PROPS, None, None)
+        .unwrap();
     g.add_edge(1116793271088085151, 2, 1, NO_PROPS, Some("a"))
         .unwrap();
     g.add_edge(0, 9, 1, NO_PROPS, None).unwrap();
diff --git a/raphtory/tests/views_test.rs b/raphtory/tests/views_test.rs
index 7087c7df10..fdf70f6a0f 100644
--- a/raphtory/tests/views_test.rs
+++ b/raphtory/tests/views_test.rs
@@ -1,7 +1,6 @@
 use itertools::Itertools;
-use quickcheck::TestResult;
-use quickcheck_macros::quickcheck;
-use rand::prelude::*;
+use proptest::{prop_assert, prop_assert_eq, prop_assume, proptest};
+use rand::{prelude::*, rng};
 use raphtory::{
     algorithms::centrality::degree_centrality::degree_centrality,
     db::graph::{graph::assert_graph_equal, views::window_graph::WindowedGraph},
@@ -16,8 +15,6 @@ use raphtory_api::core::{
 };
 use rayon::prelude::*;
 use std::ops::Range;
-#[cfg(feature = "storage")]
-use tempfile::TempDir;
 use tracing::{error, info};
 
 #[test]
@@ -122,7 +119,7 @@ fn graph_has_node_check_fail() {
     let graph = Graph::new();
 
     for (t, v) in &vs {
-        graph.add_node(*t, *v, NO_PROPS, None).unwrap();
+        graph.add_node(*t, *v, NO_PROPS, None, None).unwrap();
     }
 
     // FIXME: Issue #46: arrow_test(&graph, test)
@@ -132,251 +129,140 @@ fn graph_has_node_check_fail() {
     });
 }
 
-#[quickcheck]
-fn windowed_graph_has_node(mut vs: Vec<(i64, u64)>) -> TestResult {
-    global_info_logger();
-    if vs.is_empty() {
-        return TestResult::discard();
-    }
+#[test]
+fn windowed_graph_has_node() {
+    proptest!(|(mut vs: Vec<(i64, u64)>)| {
+        global_info_logger();
+        prop_assume!(!vs.is_empty());
 
-    vs.sort_by_key(|v| v.1); // Sorted by node
-    vs.dedup_by_key(|v| v.1); // Have each node only once to avoid headaches
-    vs.sort_by_key(|v| v.0); // Sorted by time
+        vs.sort_by_key(|v| v.1); // Sorted by node
+        vs.dedup_by_key(|v| v.1); // Have each node only once to avoid headaches
+        vs.sort_by_key(|v| v.0); // Sorted by time
 
-    let rand_start_index = thread_rng().gen_range(0..vs.len());
-    let rand_end_index = thread_rng().gen_range(rand_start_index..vs.len());
+        let rand_start_index = rng().random_range(0..vs.len());
+        let rand_end_index = rng().random_range(rand_start_index..vs.len());
 
-    let g = Graph::new();
+        let g = Graph::new();
 
-    for (t, v) in &vs {
-        g.add_node(*t, *v, NO_PROPS, None)
-            .map_err(|err| error!("{:?}", err))
-            .ok();
-    }
+        for (t, v) in &vs {
+            g.add_node(*t, *v, NO_PROPS, None, None)
+                .map_err(|err| error!("{:?}", err))
+                .ok();
+        }
 
-    let start = vs.get(rand_start_index).expect("start index in range").0;
-    let end = vs.get(rand_end_index).expect("end index in range").0;
+        let start = vs.get(rand_start_index).expect("start index in range").0;
+        let end = vs.get(rand_end_index).expect("end index in range").0;
 
-    let wg = g.window(start, end);
+        let wg = g.window(start, end);
 
-    let rand_test_index: usize = thread_rng().gen_range(0..vs.len());
+        let rand_test_index: usize = rng().random_range(0..vs.len());
 
-    let (i, v) = vs.get(rand_test_index).expect("test index in range");
-    if (start..end).contains(i) {
-        if wg.has_node(*v) {
-            TestResult::passed()
+        let (i, v) = vs.get(rand_test_index).expect("test index in range");
+        if (start..end).contains(i) {
+            prop_assert!(wg.has_node(*v), "Node {:?} was not in window {:?}", (i, v), start..end);
         } else {
-            TestResult::error(format!(
-                "Node {:?} was not in window {:?}",
-                (i, v),
-                start..end
-            ))
+            prop_assert!(!wg.has_node(*v), "Node {:?} was in window {:?}", (i, v), start..end);
         }
-    } else if !wg.has_node(*v) {
-        TestResult::passed()
-    } else {
-        TestResult::error(format!("Node {:?} was in window {:?}", (i, v), start..end))
-    }
+    });
 }
 
-// FIXME: Issue #46
-// #[quickcheck]
-// fn windowed_disk_graph_has_node(mut vs: Vec<(i64, u64)>) -> TestResult {
-//     global_info_logger();
-//      if vs.is_empty() {
-//         return TestResult::discard();
-//     }
-//
-//     vs.sort_by_key(|v| v.1); // Sorted by node
-//     vs.dedup_by_key(|v| v.1); // Have each node only once to avoid headaches
-//     vs.sort_by_key(|v| v.0); // Sorted by time
-//
-//     let rand_start_index = thread_rng().gen_range(0..vs.len());
-//     let rand_end_index = thread_rng().gen_range(rand_start_index..vs.len());
-//
-//     let g = Graph::new();
-//     for (t, v) in &vs {
-//         g.add_node(*t, *v, NO_PROPS, None)
-//             .map_err(|err| error!("{:?}", err))
-//             .ok();
-//     }
-//     let test_dir = TempDir::new().unwrap();
-#[cfg(feature = "storage")]
-//     let g = g.persist_as_disk_graph(test_dir.path()).unwrap();
-//
-//     let start = vs.get(rand_start_index).expect("start index in range").0;
-//     let end = vs.get(rand_end_index).expect("end index in range").0;
-//
-//     let wg = g.window(start, end);
-//
-//     let rand_test_index: usize = thread_rng().gen_range(0..vs.len());
-//
-//     let (i, v) = vs.get(rand_test_index).expect("test index in range");
-//     if (start..end).contains(i) {
-//         if wg.has_node(*v) {
-//             TestResult::passed()
-//         } else {
-//             TestResult::error(format!(
-//                 "Node {:?} was not in window {:?}",
-//                 (i, v),
-//                 start..end
-//             ))
-//         }
-//     } else if !wg.has_node(*v) {
-//         TestResult::passed()
-//     } else {
-//         TestResult::error(format!("Node {:?} was in window {:?}", (i, v), start..end))
-//     }
-// }
-#[quickcheck]
-fn windowed_graph_has_edge(mut edges: Vec<(i64, (u64, u64))>) -> TestResult {
-    if edges.is_empty() {
-        return TestResult::discard();
-    }
+#[test]
+fn windowed_graph_has_edge() {
+    proptest!(|(mut edges: Vec<(i64, (u64, u64))>)| {
+        prop_assume!(!edges.is_empty());
 
-    edges.sort_by_key(|e| e.1); // Sorted by edge
-    edges.dedup_by_key(|e| e.1); // Have each edge only once to avoid headaches
-    edges.sort_by_key(|e| e.0); // Sorted by time
+        edges.sort_by_key(|e| e.1); // Sorted by edge
+        edges.dedup_by_key(|e| e.1); // Have each edge only once to avoid headaches
+        edges.sort_by_key(|e| e.0); // Sorted by time
 
-    let rand_start_index = thread_rng().gen_range(0..edges.len());
-    let rand_end_index = thread_rng().gen_range(rand_start_index..edges.len());
+        let rand_start_index = rng().random_range(0..edges.len());
+        let rand_end_index = rng().random_range(rand_start_index..edges.len());
 
-    let g = Graph::new();
+        let g = Graph::new();
 
-    for (t, e) in &edges {
-        g.add_edge(*t, e.0, e.1, NO_PROPS, None).unwrap();
-    }
+        for (t, e) in &edges {
+            g.add_edge(*t, e.0, e.1, NO_PROPS, None).unwrap();
+        }
 
-    let start = edges.get(rand_start_index).expect("start index in range").0;
-    let end = edges.get(rand_end_index).expect("end index in range").0;
+        let start = edges.get(rand_start_index).expect("start index in range").0;
+        let end = edges.get(rand_end_index).expect("end index in range").0;
 
-    let wg = g.window(start, end);
+        let wg = g.window(start, end);
 
-    let rand_test_index: usize = thread_rng().gen_range(0..edges.len());
+        let rand_test_index: usize = rng().random_range(0..edges.len());
 
-    let (i, e) = edges.get(rand_test_index).expect("test index in range");
-    if (start..end).contains(i) {
-        if wg.has_edge(e.0, e.1) {
-            TestResult::passed()
+        let (i, e) = edges.get(rand_test_index).expect("test index in range");
+        if (start..end).contains(i) {
+            prop_assert!(wg.has_edge(e.0, e.1), "Edge {:?} was not in window {:?}", (i, e), start..end);
         } else {
-            TestResult::error(format!(
-                "Edge {:?} was not in window {:?}",
-                (i, e),
-                start..end
-            ))
+            prop_assert!(!wg.has_edge(e.0, e.1), "Edge {:?} was in window {:?}", (i, e), start..end);
         }
-    } else if !wg.has_edge(e.0, e.1) {
-        TestResult::passed()
-    } else {
-        TestResult::error(format!("Edge {:?} was in window {:?}", (i, e), start..end))
-    }
+    });
 }
 
-#[cfg(feature = "storage")]
-#[quickcheck]
-fn windowed_disk_graph_has_edge(mut edges: Vec<(i64, (u64, u64))>) -> TestResult {
-    if edges.is_empty() {
-        return TestResult::discard();
-    }
-
-    edges.sort_by_key(|e| e.1); // Sorted by edge
-    edges.dedup_by_key(|e| e.1); // Have each edge only once to avoid headaches
-    edges.sort_by_key(|e| e.0); // Sorted by time
-
-    let rand_start_index = thread_rng().gen_range(0..edges.len());
-    let rand_end_index = thread_rng().gen_range(rand_start_index..edges.len());
-
-    let g = Graph::new();
-
-    for (t, e) in &edges {
-        g.add_edge(*t, e.0, e.1, NO_PROPS, None).unwrap();
-    }
-    let test_dir = TempDir::new().unwrap();
-    let g = g.persist_as_disk_graph(test_dir.path()).unwrap();
+#[test]
+fn windowed_graph_edge_count() {
+    proptest!(|(mut edges: Vec<(i64, (u64, u64))>, window: Range<i64>)| {
+        global_info_logger();
+        prop_assume!(window.end >= window.start);
 
-    let start = edges.get(rand_start_index).expect("start index in range").0;
-    let end = edges.get(rand_end_index).expect("end index in range").0;
+        edges.sort_by_key(|e| e.1); // Sorted by edge
+        edges.dedup_by_key(|e| e.1); // Have each edge only once to avoid headaches
 
-    let wg = g.window(start, end);
+        let true_edge_count = edges.iter().filter(|e| window.contains(&e.0)).count();
 
-    let rand_test_index: usize = thread_rng().gen_range(0..edges.len());
+        let g = Graph::new();
 
-    let (i, e) = edges.get(rand_test_index).expect("test index in range");
-    if (start..end).contains(i) {
-        if wg.has_edge(e.0, e.1) {
-            TestResult::passed()
-        } else {
-            TestResult::error(format!(
-                "Edge {:?} was not in window {:?}",
-                (i, e),
-                start..end
-            ))
+        for (t, e) in &edges {
+            g.add_edge(*t, e.0, e.1, [("test".to_owned(), Prop::Bool(true))], None)
+                .unwrap();
         }
-    } else if !wg.has_edge(e.0, e.1) {
-        TestResult::passed()
-    } else {
-        TestResult::error(format!("Edge {:?} was in window {:?}", (i, e), start..end))
-    }
-}
-
-#[quickcheck]
-fn windowed_graph_edge_count(mut edges: Vec<(i64, (u64, u64))>, window: Range<i64>) -> TestResult {
-    global_info_logger();
-    if window.end < window.start {
-        return TestResult::discard();
-    }
-    edges.sort_by_key(|e| e.1); // Sorted by edge
-    edges.dedup_by_key(|e| e.1); // Have each edge only once to avoid headaches
-
-    let true_edge_count = edges.iter().filter(|e| window.contains(&e.0)).count();
 
-    let g = Graph::new();
-
-    for (t, e) in &edges {
-        g.add_edge(*t, e.0, e.1, [("test".to_owned(), Prop::Bool(true))], None)
-            .unwrap();
-    }
-
-    let wg = g.window(window.start, window.end);
-    if wg.count_edges() != true_edge_count {
-        info!(
-            "failed, g.num_edges() = {}, true count = {}",
-            wg.count_edges(),
-            true_edge_count
-        );
-        info!("g.edges() = {:?}", wg.edges().iter().collect_vec());
-    }
-    TestResult::from_bool(wg.count_edges() == true_edge_count)
+        let wg = g.window(window.start, window.end);
+        if wg.count_edges() != true_edge_count {
+            info!(
+                "failed, g.num_edges() = {}, true count = {}",
+                wg.count_edges(),
+                true_edge_count
+            );
+            info!("g.edges() = {:?}", wg.edges().iter().collect_vec());
+        }
+        prop_assert_eq!(wg.count_edges(), true_edge_count);
+    });
 }
 
-#[quickcheck]
-fn trivial_window_has_all_edges(edges: Vec<(i64, u64, u64)>) -> bool {
-    let g = Graph::new();
-    edges
-        .into_par_iter()
-        .filter(|e| e.0 < i64::MAX)
-        .for_each(|(t, src, dst)| {
-            g.add_edge(t, src, dst, [("test".to_owned(), Prop::Bool(true))], None)
-                .unwrap();
-        });
-    let w = g.window(i64::MIN, i64::MAX);
-    g.edges()
-        .iter()
-        .all(|e| w.has_edge(e.src().id(), e.dst().id()))
+#[test]
+fn trivial_window_has_all_edges() {
+    proptest!(|(edges: Vec<(i64, u64, u64)>)| {
+        let g = Graph::new();
+        edges
+            .into_par_iter()
+            .filter(|e| e.0 < i64::MAX)
+            .for_each(|(t, src, dst)| {
+                g.add_edge(t, src, dst, [("test".to_owned(), Prop::Bool(true))], None)
+                    .unwrap();
+            });
+        let w = g.window(i64::MIN, i64::MAX);
+        prop_assert!(g.edges()
+            .iter()
+            .all(|e| w.has_edge(e.src().id(), e.dst().id())));
+    });
 }
 
-#[quickcheck]
-fn large_node_in_window(dsts: Vec<u64>) -> bool {
-    let dsts: Vec<u64> = dsts.into_iter().unique().collect();
-    let n = dsts.len();
-    let g = Graph::new();
-
-    for dst in dsts {
-        let t = 1;
-        g.add_edge(t, 0, dst, NO_PROPS, None).unwrap();
-    }
-    let w = g.window(i64::MIN, i64::MAX);
-    w.count_edges() == n
+#[test]
+fn large_node_in_window() {
+    proptest!(|(dsts: Vec<u64>)| {
+        let dsts: Vec<u64> = dsts.into_iter().unique().collect();
+        let n = dsts.len();
+        let g = Graph::new();
+
+        for dst in dsts {
+            let t = 1;
+            g.add_edge(t, 0, dst, NO_PROPS, None).unwrap();
+        }
+        let w = g.window(i64::MIN, i64::MAX);
+        prop_assert_eq!(w.count_edges(), n);
+    });
 }
 
 #[test]
@@ -457,6 +343,7 @@ fn windowed_graph_nodes() {
             1,
             [("type", "wallet".into_prop()), ("cost", 99.5.into_prop())],
             None,
+            None,
         )
         .unwrap();
 
@@ -466,6 +353,7 @@ fn windowed_graph_nodes() {
             2,
             [("type", "wallet".into_prop()), ("cost", 10.0.into_prop())],
             None,
+            None,
         )
         .unwrap();
 
@@ -475,6 +363,7 @@ fn windowed_graph_nodes() {
             3,
             [("type", "wallet".into_prop()), ("cost", 76.2.into_prop())],
             None,
+            None,
         )
         .unwrap();
 
@@ -556,10 +445,10 @@ fn test_view_resetting() {
 #[test]
 fn test_entity_history() {
     let graph = Graph::new();
-    graph.add_node(0, 0, NO_PROPS, None).unwrap();
-    graph.add_node(1, 0, NO_PROPS, None).unwrap();
-    graph.add_node(2, 0, NO_PROPS, None).unwrap();
-    graph.add_node(3, 0, NO_PROPS, None).unwrap();
+    graph.add_node(0, 0, NO_PROPS, None, None).unwrap();
+    graph.add_node(1, 0, NO_PROPS, None, None).unwrap();
+    graph.add_node(2, 0, NO_PROPS, None, None).unwrap();
+    graph.add_node(3, 0, NO_PROPS, None, None).unwrap();
     graph.add_edge(0, 1, 2, NO_PROPS, None).unwrap();
     graph.add_edge(1, 1, 2, NO_PROPS, None).unwrap();
     graph.add_edge(2, 1, 2, NO_PROPS, None).unwrap();
@@ -624,7 +513,8 @@ fn test_entity_history() {
                 .nodes()
                 .neighbours()
                 .latest_time()
-                .map(|it| it.flatten().collect_vec())
+                .sorted_by_key(|(n, _)| n.id())
+                .map(|(_, it)| it.flatten().collect_vec())
                 .collect_vec(),
             [vec![], vec![3, 7], vec![7], vec![7],]
         );
@@ -634,7 +524,8 @@ fn test_entity_history() {
                 .nodes()
                 .neighbours()
                 .earliest_time()
-                .map(|it| it.flatten().collect_vec())
+                .sorted_by_key(|(n, _)| n.id())
+                .map(|(_, it)| it.flatten().collect_vec())
                 .collect_vec(),
             [vec![], vec![0, 4], vec![0], vec![0],]
         );
@@ -642,10 +533,6 @@ fn test_entity_history() {
 }
 
 mod test_filters_window_graph {
-    use raphtory::{
-        db::{api::view::StaticGraphViewOps, graph::assertions::GraphTransformer},
-        prelude::TimeOps,
-    };
 
     mod test_nodes_filters_window_graph {
         use raphtory::{
@@ -665,7 +552,6 @@ mod test_filters_window_graph {
         use raphtory_storage::mutation::{
             addition_ops::InternalAdditionOps, property_addition_ops::InternalPropertyAdditionOps,
         };
-        use std::sync::Arc;
 
         use raphtory::{
             db::{
@@ -808,7 +694,9 @@ mod test_filters_window_graph {
 
             // Add nodes to the graph
             for (id, name, props, layer) in &nodes {
-                graph.add_node(*id, name, props.clone(), *layer).unwrap();
+                graph
+                    .add_node(*id, name, props.clone(), *layer, None)
+                    .unwrap();
             }
 
             // Metadata property assignments
@@ -866,7 +754,7 @@ mod test_filters_window_graph {
                     ("q1", Prop::U64(0u64)),
                     (
                         "x",
-                        Prop::List(Arc::from(vec![Prop::U64(1), Prop::U64(6), Prop::U64(9)])),
+                        Prop::list(vec![Prop::U64(1), Prop::U64(6), Prop::U64(9)]),
                     ),
                 ],
                 None,
@@ -874,7 +762,9 @@ mod test_filters_window_graph {
 
             // Add nodes to the graph
             for (id, name, props, layer) in &nodes {
-                graph.add_node(*id, name, props.clone(), *layer).unwrap();
+                graph
+                    .add_node(*id, name, props.clone(), *layer, None)
+                    .unwrap();
             }
 
             graph
@@ -967,7 +857,7 @@ mod test_filters_window_graph {
         #[test]
         fn test_nodes_filters_for_node_name_in() {
             // TODO: Enable event_disk_graph once bug fixed: https://github.com/Pometry/Raphtory/issues/2098
-            let filter = NodeFilter::name().is_in(vec!["N2".into()]);
+            let filter = NodeFilter::name().is_in(vec!["N2"]);
             let expected_results = vec!["N2"];
             assert_filter_nodes_results(
                 init_graph,
@@ -984,7 +874,7 @@ mod test_filters_window_graph {
                 TestVariants::EventOnly,
             );
 
-            let filter = NodeFilter::name().is_in(vec!["N2".into(), "N5".into()]);
+            let filter = NodeFilter::name().is_in(vec!["N2", "N5"]);
             let expected_results = vec!["N2", "N5"];
             assert_filter_nodes_results(
                 init_graph,
@@ -1004,7 +894,7 @@ mod test_filters_window_graph {
 
         #[test]
         fn test_nodes_filters_pg_for_node_name_in() {
-            let filter = NodeFilter::name().is_in(vec!["N2".into()]);
+            let filter = NodeFilter::name().is_in(vec!["N2"]);
             let expected_results = vec!["N2"];
             assert_filter_nodes_results(
                 init_graph,
@@ -1021,7 +911,7 @@ mod test_filters_window_graph {
                 TestVariants::PersistentOnly,
             );
 
-            let filter = NodeFilter::name().is_in(vec!["N2".into(), "N5".into()]);
+            let filter = NodeFilter::name().is_in(vec!["N2", "N5"]);
             let expected_results = vec!["N2", "N5"];
             assert_filter_nodes_results(
                 init_graph,
@@ -1042,7 +932,7 @@ mod test_filters_window_graph {
         #[test]
         fn test_nodes_filters_for_node_name_not_in() {
             // TODO: Enable event_disk_graph once bug fixed: https://github.com/Pometry/Raphtory/issues/2098
-            let filter = NodeFilter::name().is_not_in(vec!["N5".into()]);
+            let filter = NodeFilter::name().is_not_in(vec!["N5"]);
             let expected_results = vec!["N1", "N2", "N3", "N6"];
             assert_filter_nodes_results(
                 init_graph,
@@ -1062,7 +952,7 @@ mod test_filters_window_graph {
 
         #[test]
         fn test_nodes_filters_pg_for_node_name_not_in() {
-            let filter = NodeFilter::name().is_not_in(vec!["N5".into()]);
+            let filter = NodeFilter::name().is_not_in(vec!["N5"]);
             let expected_results = vec![
                 "N1", "N10", "N11", "N12", "N13", "N14", "N15", "N2", "N3", "N6", "N7", "N8", "N9",
             ];
@@ -1169,7 +1059,7 @@ mod test_filters_window_graph {
         #[test]
         fn test_nodes_filters_for_node_type_in() {
             // TODO: Enable event_disk_graph once bug fixed: https://github.com/Pometry/Raphtory/issues/2098
-            let filter = NodeFilter::node_type().is_in(vec!["fire_nation".into()]);
+            let filter = NodeFilter::node_type().is_in(vec!["fire_nation"]);
             let expected_results = vec!["N6"];
             assert_filter_nodes_results(
                 init_graph,
@@ -1186,8 +1076,7 @@ mod test_filters_window_graph {
                 vec![TestGraphVariants::Graph],
             );
 
-            let filter =
-                NodeFilter::node_type().is_in(vec!["fire_nation".into(), "air_nomad".into()]);
+            let filter = NodeFilter::node_type().is_in(vec!["fire_nation", "air_nomad"]);
             let expected_results = vec!["N1", "N3", "N5", "N6"];
             assert_filter_nodes_results(
                 init_graph,
@@ -1207,7 +1096,7 @@ mod test_filters_window_graph {
 
         #[test]
         fn test_nodes_filters_pg_for_node_type_in() {
-            let filter = NodeFilter::node_type().is_in(vec!["fire_nation".into()]);
+            let filter = NodeFilter::node_type().is_in(vec!["fire_nation"]);
             let expected_results = vec!["N6", "N8"];
             assert_filter_nodes_results(
                 init_graph,
@@ -1224,8 +1113,7 @@ mod test_filters_window_graph {
                 TestVariants::PersistentOnly,
             );
 
-            let filter =
-                NodeFilter::node_type().is_in(vec!["fire_nation".into(), "air_nomad".into()]);
+            let filter = NodeFilter::node_type().is_in(vec!["fire_nation", "air_nomad"]);
             let expected_results = vec!["N1", "N3", "N5", "N6", "N7", "N8"];
             assert_filter_nodes_results(
                 init_graph,
@@ -1246,7 +1134,7 @@ mod test_filters_window_graph {
         #[test]
         fn test_nodes_filters_for_node_type_not_in() {
             // TODO: Enable event_disk_graph once bug fixed: https://github.com/Pometry/Raphtory/issues/2098
-            let filter = NodeFilter::node_type().is_not_in(vec!["fire_nation".into()]);
+            let filter = NodeFilter::node_type().is_not_in(vec!["fire_nation"]);
             let expected_results = vec!["N1", "N2", "N3", "N5"];
             assert_filter_nodes_results(
                 init_graph,
@@ -1266,7 +1154,7 @@ mod test_filters_window_graph {
 
         #[test]
         fn test_nodes_filters_pg_for_node_type_not_in() {
-            let filter = NodeFilter::node_type().is_not_in(vec!["fire_nation".into()]);
+            let filter = NodeFilter::node_type().is_not_in(vec!["fire_nation"]);
             let expected_results = vec![
                 "N1", "N10", "N11", "N12", "N13", "N14", "N15", "N2", "N3", "N5", "N7", "N9",
             ];
@@ -1374,11 +1262,11 @@ mod test_filters_window_graph {
                 TestVariants::EventOnly,
             );
 
-            let filter = NodeFilter.property("x").eq(Prop::List(Arc::new(vec![
+            let filter = NodeFilter.property("x").eq(Prop::list(vec![
                 Prop::U64(1),
                 Prop::U64(6),
                 Prop::U64(9),
-            ])));
+            ]));
             let expected_results = vec!["N14"];
             // TODO: List(U64) not supported as disk_graph property
             // assert_filter_nodes_results_w!(
@@ -1493,11 +1381,11 @@ mod test_filters_window_graph {
                 TestVariants::PersistentOnly,
             );
 
-            let filter = NodeFilter.property("x").eq(Prop::List(Arc::new(vec![
+            let filter = NodeFilter.property("x").eq(Prop::list(vec![
                 Prop::U64(1),
                 Prop::U64(6),
                 Prop::U64(9),
-            ])));
+            ]));
             let expected_results = vec!["N14"];
             // TODO: List(U64) not supported as disk_graph property
             // assert_filter_nodes_results_pg_w!(
@@ -1973,11 +1861,9 @@ mod test_filters_window_graph {
                 vec![TestGraphVariants::Graph],
             );
 
-            let filter = NodeFilter.property("x").gt(Prop::List(Arc::new(vec![
-                Prop::U64(1),
-                Prop::U64(6),
-                Prop::U64(9),
-            ])));
+            let filter = NodeFilter.property("x").gt(Prop::List(
+                vec![Prop::U64(1), Prop::U64(6), Prop::U64(9)].into(),
+            ));
             let graph = init_graph(Graph::new());
             assert!(matches!(
                 graph.window(1, 9).filter(filter.clone()).unwrap_err(),
@@ -2812,7 +2698,6 @@ mod test_filters_window_graph {
             prelude::{AdditionOps, Graph, GraphViewOps, PropertyAdditionOps, TimeOps, NO_PROPS},
         };
         use raphtory_api::core::{entities::properties::prop::Prop, storage::arc_str::ArcStr};
-        use std::sync::Arc;
 
         fn init_graph<G: StaticGraphViewOps + AdditionOps + PropertyAdditionOps>(graph: G) -> G {
             let edges = vec![
@@ -3026,9 +2911,9 @@ mod test_filters_window_graph {
                     .unwrap();
             }
 
-            graph.add_node(1, "N1", NO_PROPS, None).unwrap();
-            graph.add_node(2, "N2", NO_PROPS, None).unwrap();
-            graph.add_node(3, "N3", NO_PROPS, None).unwrap();
+            graph.add_node(1, "N1", NO_PROPS, None, None).unwrap();
+            graph.add_node(2, "N2", NO_PROPS, None, None).unwrap();
+            graph.add_node(3, "N3", NO_PROPS, None, None).unwrap();
 
             graph
         }
@@ -3042,7 +2927,7 @@ mod test_filters_window_graph {
                     ("q1", Prop::U64(0u64)),
                     (
                         "x",
-                        Prop::List(Arc::from(vec![Prop::U64(1), Prop::U64(6), Prop::U64(9)])),
+                        Prop::list(vec![Prop::U64(1), Prop::U64(6), Prop::U64(9)]),
                     ),
                 ],
                 None,
@@ -3144,7 +3029,7 @@ mod test_filters_window_graph {
 
         #[test]
         fn test_edges_filters_for_dst_in() {
-            let filter = EdgeFilter::dst().name().is_in(vec!["N2".into()]);
+            let filter = EdgeFilter::dst().name().is_in(vec!["N2"]);
             let expected_results = vec!["N1->N2"];
             assert_filter_edges_results(
                 init_graph,
@@ -3161,9 +3046,7 @@ mod test_filters_window_graph {
                 TestVariants::EventOnly,
             );
 
-            let filter = EdgeFilter::dst()
-                .name()
-                .is_in(vec!["N2".into(), "N5".into()]);
+            let filter = EdgeFilter::dst().name().is_in(vec!["N2", "N5"]);
             let expected_results = vec!["N1->N2"];
             assert_filter_edges_results(
                 init_graph,
@@ -3184,7 +3067,7 @@ mod test_filters_window_graph {
         #[test]
         fn test_edges_filters_pg_for_dst_in() {
             // TODO: PropertyFilteringNotImplemented for variants persistent_graph, persistent_disk_graph for filter_edges.
-            let filter = EdgeFilter::dst().name().is_in(vec!["N2".into()]);
+            let filter = EdgeFilter::dst().name().is_in(vec!["N2"]);
             let expected_results = vec!["N1->N2"];
             assert_filter_edges_results(
                 init_graph,
@@ -3201,9 +3084,7 @@ mod test_filters_window_graph {
                 TestVariants::PersistentOnly,
             );
 
-            let filter = EdgeFilter::dst()
-                .name()
-                .is_in(vec!["N2".into(), "N5".into()]);
+            let filter = EdgeFilter::dst().name().is_in(vec!["N2", "N5"]);
             let expected_results = vec!["N1->N2"];
             assert_filter_edges_results(
                 init_graph,
@@ -3223,7 +3104,7 @@ mod test_filters_window_graph {
 
         #[test]
         fn test_edges_filters_for_dst_not_in() {
-            let filter = EdgeFilter::dst().name().is_not_in(vec!["N5".into()]);
+            let filter = EdgeFilter::dst().name().is_not_in(vec!["N5"]);
             let expected_results = vec!["N1->N2", "N2->N3", "N3->N4", "N5->N6", "N6->N7"];
             assert_filter_edges_results(
                 init_graph,
@@ -3243,7 +3124,7 @@ mod test_filters_window_graph {
 
         #[test]
         fn test_edges_filters_pg_for_dst_not_in() {
-            let filter = EdgeFilter::dst().name().is_not_in(vec!["N5".into()]);
+            let filter = EdgeFilter::dst().name().is_not_in(vec!["N5"]);
             let expected_results = vec![
                 "N1->N2", "N10->N11", "N11->N12", "N12->N13", "N13->N14", "N14->N15", "N15->N1",
                 "N2->N3", "N3->N4", "N5->N6", "N6->N7", "N7->N8", "N8->N9", "N9->N10",
@@ -3352,11 +3233,11 @@ mod test_filters_window_graph {
                 TestVariants::EventOnly,
             );
 
-            let filter = EdgeFilter.property("x").eq(Prop::List(Arc::new(vec![
+            let filter = EdgeFilter.property("x").eq(Prop::list(vec![
                 Prop::U64(1),
                 Prop::U64(6),
                 Prop::U64(9),
-            ])));
+            ]));
             let expected_results = vec!["N14->N15"];
             // TODO: List(U64) not supported as disk_graph property
             // assert_filter_edges_results_w!(
@@ -3473,11 +3354,11 @@ mod test_filters_window_graph {
                 TestVariants::PersistentOnly,
             );
 
-            let filter = EdgeFilter.property("x").eq(Prop::List(Arc::new(vec![
+            let filter = EdgeFilter.property("x").eq(Prop::list(vec![
                 Prop::U64(1),
                 Prop::U64(6),
                 Prop::U64(9),
-            ])));
+            ]));
             let expected_results = vec!["N14->N15"];
             // TODO: List(U64) not supported as disk_graph property
             // assert_filter_edges_results_pg_w!(
@@ -3684,11 +3565,11 @@ mod test_filters_window_graph {
                 TestVariants::PersistentOnly,
             );
 
-            let filter = EdgeFilter.property("x").ne(Prop::List(Arc::new(vec![
+            let filter = EdgeFilter.property("x").ne(Prop::list(vec![
                 Prop::U64(1),
                 Prop::U64(6),
                 Prop::U64(9),
-            ])));
+            ]));
             let expected_results = Vec::<&str>::new();
             assert_filter_edges_results(
                 init_graph2,
@@ -3980,11 +3861,9 @@ mod test_filters_window_graph {
                 TestVariants::EventOnly,
             );
 
-            let filter = EdgeFilter.property("x").gt(Prop::List(Arc::new(vec![
-                Prop::U64(1),
-                Prop::U64(6),
-                Prop::U64(9),
-            ])));
+            let filter = EdgeFilter.property("x").gt(Prop::List(
+                vec![Prop::U64(1), Prop::U64(6), Prop::U64(9)].into(),
+            ));
             let graph = init_graph(Graph::new());
             assert!(matches!(
                 graph.window(1, 9).filter(filter.clone()).unwrap_err(),
diff --git a/ui-tests b/ui-tests
deleted file mode 160000
index c24a7b125b..0000000000
--- a/ui-tests
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit c24a7b125b6c72a6df09061304f242d52b72a947
diff --git a/ui-tests/.dockerignore b/ui-tests/.dockerignore
new file mode 100644
index 0000000000..40b878db5b
--- /dev/null
+++ b/ui-tests/.dockerignore
@@ -0,0 +1 @@
+node_modules/
\ No newline at end of file
diff --git a/ui-tests/.gitignore b/ui-tests/.gitignore
new file mode 100644
index 0000000000..6099543a6a
--- /dev/null
+++ b/ui-tests/.gitignore
@@ -0,0 +1,38 @@
+.env
+
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+# Build artifacts
+node_modules/
+dist
+dist-ssr
+target
+*.local
+.python-version
+__pycache__
+pyrightconfig.json
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.zed
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
+
+# Playwright
+/test-results/
+/playwright-report/
+/blob-report/
+/playwright/.cache/
diff --git a/ui-tests/.husky/pre-commit b/ui-tests/.husky/pre-commit
new file mode 100644
index 0000000000..c511858dd1
--- /dev/null
+++ b/ui-tests/.husky/pre-commit
@@ -0,0 +1,3 @@
+npx lint-staged
+
+exit $status
\ No newline at end of file
diff --git a/ui-tests/.lintstagedrc.mjs b/ui-tests/.lintstagedrc.mjs
new file mode 100644
index 0000000000..9b4789808a
--- /dev/null
+++ b/ui-tests/.lintstagedrc.mjs
@@ -0,0 +1,12 @@
+const config = {
+    '!(**/__generated/**/*)*.{ts,tsx,graphql}': () => ['pnpm run tsc'],
+    '!(**/__generated/**/*)!(**/types/**/*)*.{ts,tsx,graphql,cjs,mjs,js,jsx}': [
+        'pnpm run eslint',
+        'pnpm run format',
+    ],
+    '!(**/__generated/**/*)*.css': (filenames) => [
+        `pnpm run format ${filenames}`,
+    ],
+    '!(**/__generated/**/*)*.html': ['pnpm run format'],
+};
+export default config;
diff --git a/ui-tests/.prettierignore b/ui-tests/.prettierignore
new file mode 100644
index 0000000000..3393c73870
--- /dev/null
+++ b/ui-tests/.prettierignore
@@ -0,0 +1,10 @@
+# Ignore artifacts:
+build
+coverage
+dist
+types/
+# Ignore build dependencies
+node_modules/
+pnpm-lock.yaml
+*bundled*
+genql/
\ No newline at end of file
diff --git a/ui-tests/.prettierrc.json b/ui-tests/.prettierrc.json
new file mode 100644
index 0000000000..9b0bb437a1
--- /dev/null
+++ b/ui-tests/.prettierrc.json
@@ -0,0 +1,4 @@
+{
+    "tabWidth": 4,
+    "singleQuote": true
+}
diff --git a/ui-tests/README.md b/ui-tests/README.md
new file mode 100644
index 0000000000..7fb9c5810a
--- /dev/null
+++ b/ui-tests/README.md
@@ -0,0 +1,9 @@
+# pometry-ui E2E Tests
+
+Warning: This repository is not meant to be used standalone, but is to be included as a submodule in the pometry-ui or
+raphtory monorepos for testing the UI.
+
+This repo contains a set of playwright tests for testing the UI with raphtory from end to end.
+
+It assumes that the vanilla UI exists at a provided base URL. This base URL is read by dotenv, and can be set by .env
+file or environment variable.
diff --git a/ui-tests/eslint.config.mjs b/ui-tests/eslint.config.mjs
new file mode 100644
index 0000000000..675236309b
--- /dev/null
+++ b/ui-tests/eslint.config.mjs
@@ -0,0 +1,135 @@
+import eslint from '@eslint/js';
+import { globalIgnores } from 'eslint/config';
+import importPlugin from 'eslint-plugin-import';
+import react from 'eslint-plugin-react';
+import reactRefresh from 'eslint-plugin-react-refresh';
+import unusedImports from 'eslint-plugin-unused-imports';
+import globals from 'globals';
+import tseslint, { configs as tsEslintConfigs } from 'typescript-eslint';
+
+export default tseslint.config(
+    eslint.configs.recommended,
+    tsEslintConfigs.strict,
+    tsEslintConfigs.stylistic,
+    [
+        {
+            languageOptions: {
+                globals: {
+                    ...globals.browser,
+                    ...globals.node,
+                },
+                ecmaVersion: 'latest',
+                sourceType: 'module',
+            },
+
+            extends: [
+                importPlugin.flatConfigs.recommended,
+                importPlugin.flatConfigs.typescript,
+            ],
+            //     fixupConfigRules(
+            //     compat.extends(
+            //         'eslint:recommended',
+            //         'plugin:@typescript-eslint/recommended',
+            //         'plugin:react/recommended',
+            //         'plugin:react-hooks/recommended',
+            //         'plugin:import/recommended',
+            //         'plugin:import/typescript',
+            //         'plugin:yml/prettier',
+            //     ),
+            // ),
+
+            settings: {
+                // typescript: true,
+                'import/resolver': {
+                    typescript: true,
+                    node: true,
+                },
+                react: {
+                    version: 'detect',
+                },
+            },
+
+            plugins: {
+                react,
+                'react-refresh': reactRefresh,
+                'unused-imports': unusedImports,
+            },
+
+            rules: {
+                'react-refresh/only-export-components': 'warn',
+                'import/no-empty-named-blocks': 'error',
+                'import/order': [
+                    'error',
+                    {
+                        groups: [
+                            ['builtin', 'external', 'object', 'type'],
+                            ['internal', 'parent', 'sibling', 'index'],
+                        ],
+
+                        alphabetize: {
+                            order: 'asc',
+                            caseInsensitive: true,
+                        },
+                    },
+                ],
+                'sort-imports': [
+                    'error',
+                    {
+                        allowSeparatedGroups: true,
+                        ignoreCase: true,
+                        ignoreDeclarationSort: true,
+                        ignoreMemberSort: false,
+                        memberSyntaxSortOrder: [
+                            'none',
+                            'all',
+                            'multiple',
+                            'single',
+                        ],
+                    },
+                ],
+                '@typescript-eslint/no-unused-vars': 'off',
+                '@typescript-eslint/no-explicit-any': 'error',
+                '@typescript-eslint/no-non-null-assertion': 'off',
+                '@typescript-eslint/no-empty-function': 'off',
+                'unused-imports/no-unused-imports': 'error',
+                'unused-imports/no-unused-vars': [
+                    'warn',
+                    {
+                        vars: 'all',
+                        varsIgnorePattern: '^_',
+                        args: 'after-used',
+                        argsIgnorePattern: '^_',
+                    },
+                ],
+                'import/no-duplicates': [
+                    'error',
+                    {
+                        considerQueryString: true,
+                    },
+                ],
+                'import/no-unresolved': [
+                    'error',
+                    {
+                        ignore: ['^~icons/'],
+                    },
+                ],
+                'react/react-in-jsx-scope': 'off',
+                'react/jsx-key': 'error',
+                'react/no-array-index-key': 'warn',
+            },
+        },
+        globalIgnores([
+            '!**/.github/',
+            '!**/.ladle/',
+            '!**/.*.cjs',
+            '!**/.*.mjs',
+            '!**/.*.json',
+            '**/__generated/**/*',
+            '**/dist',
+            '**/types/',
+            '**/playwright-report/**/*',
+            '**/blob-report/**/*',
+            '**/test-results/**/*',
+        ]),
+    ],
+);
diff --git a/ui-tests/package-lock.json b/ui-tests/package-lock.json
new file mode 100644
index 0000000000..b4c3fb3292
--- /dev/null
+++ b/ui-tests/package-lock.json
@@ -0,0 +1,5148 @@
+{
+    "name": "ui-tests",
+    "version": "0.0.1",
+    "lockfileVersion": 3,
+    "requires": true,
+    "packages": {
+        "": {
+            "name": "ui-tests",
+            "version": "0.0.1",
+            "devDependencies": {
+                "@eslint/compat": "^1.3.2",
+                "@eslint/js": "^9.33.0",
+                "@playwright/test": "^1.55.0",
+                "@typescript-eslint/eslint-plugin": "^8.39.1",
+                "@typescript-eslint/parser": "^8.39.1",
+                "dotenv": "^17.2.2",
+                "eslint": "^9.33.0",
+                "eslint-import-resolver-typescript": "^4.4.4",
+                "eslint-plugin-import": "^2.32.0",
+                "eslint-plugin-react": "^7.37.5",
+                "eslint-plugin-react-hooks": "^5.2.0",
+                "eslint-plugin-react-refresh": "^0.4.20",
+                "eslint-plugin-unused-imports": "^4.1.4",
+                "eslint-plugin-yml": "^1.18.0",
+                "globals": "^16.3.0",
+                "husky": "^9.1.7",
+                "lint-staged": "^16.2.4",
+                "prettier": "^3.6.2",
+                "typescript": "^5.9.3",
+                "typescript-eslint": "^8.39.1"
+            }
+        },
+        "node_modules/@emnapi/core": {
+            "version": "1.5.0",
+            "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.5.0.tgz",
+            "integrity": "sha512-sbP8GzB1WDzacS8fgNPpHlp6C9VZe+SJP3F90W9rLemaQj2PzIuTEl1qDOYQf58YIpyjViI24y9aPWCjEzY2cg==",
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "dependencies": {
+                "@emnapi/wasi-threads": "1.1.0",
+                "tslib": "^2.4.0"
+            }
+        },
+        "node_modules/@emnapi/runtime": {
+            "version": "1.5.0",
+            "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.5.0.tgz",
+            "integrity": "sha512-97/BJ3iXHww3djw6hYIfErCZFee7qCtrneuLa20UXFCOTCfBM2cvQHjWJ2EG0s0MtdNwInarqCTz35i4wWXHsQ==",
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "dependencies": {
+                "tslib": "^2.4.0"
+            }
+        },
+        "node_modules/@emnapi/wasi-threads": {
+            "version": "1.1.0",
+            "resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.1.0.tgz",
+            "integrity": "sha512-WI0DdZ8xFSbgMjR1sFsKABJ/C5OnRrjT06JXbZKexJGrDuPTzZdDYfFlsgcCXCyf+suG5QU2e/y1Wo2V/OapLQ==",
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "dependencies": {
+                "tslib": "^2.4.0"
+            }
+        },
+        "node_modules/@eslint-community/eslint-utils": {
+            "version": "4.9.0",
+            "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.9.0.tgz",
+            "integrity": "sha512-ayVFHdtZ+hsq1t2Dy24wCmGXGe4q9Gu3smhLYALJrr473ZH27MsnSL+LKUlimp4BWJqMDMLmPpx/Q9R3OAlL4g==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "eslint-visitor-keys": "^3.4.3"
+            },
+            "engines": {
+                "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+            },
+            "funding": {
+                "url": "https://opencollective.com/eslint"
+            },
+            "peerDependencies": {
+                "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0"
+            }
+        },
+        "node_modules/@eslint-community/regexpp": {
+            "version": "4.12.1",
+            "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.1.tgz",
+            "integrity": "sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": "^12.0.0 || ^14.0.0 || >=16.0.0"
+            }
+        },
+        "node_modules/@eslint/compat": {
+            "version": "1.4.0",
+            "resolved": "https://registry.npmjs.org/@eslint/compat/-/compat-1.4.0.tgz",
+            "integrity": "sha512-DEzm5dKeDBPm3r08Ixli/0cmxr8LkRdwxMRUIJBlSCpAwSrvFEJpVBzV+66JhDxiaqKxnRzCXhtiMiczF7Hglg==",
+            "dev": true,
+            "license": "Apache-2.0",
+            "dependencies": {
+                "@eslint/core": "^0.16.0"
+            },
+            "engines": {
+                "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+            },
+            "peerDependencies": {
+                "eslint": "^8.40 || 9"
+            },
+            "peerDependenciesMeta": {
+                "eslint": {
+                    "optional": true
+                }
+            }
+        },
+        "node_modules/@eslint/config-array": {
+            "version": "0.21.0",
+            "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.21.0.tgz",
+            "integrity": "sha512-ENIdc4iLu0d93HeYirvKmrzshzofPw6VkZRKQGe9Nv46ZnWUzcF1xV01dcvEg/1wXUR61OmmlSfyeyO7EvjLxQ==",
+            "dev": true,
+            "license": "Apache-2.0",
+            "dependencies": {
+                "@eslint/object-schema": "^2.1.6",
+                "debug": "^4.3.1",
+                "minimatch": "^3.1.2"
+            },
+            "engines": {
+                "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+            }
+        },
+        "node_modules/@eslint/config-array/node_modules/brace-expansion": {
+            "version": "1.1.12",
+            "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
+            "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "balanced-match": "^1.0.0",
+                "concat-map": "0.0.1"
+            }
+        },
+        "node_modules/@eslint/config-array/node_modules/minimatch": {
+            "version": "3.1.2",
+            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+            "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+            "dev": true,
+            "license": "ISC",
+            "dependencies": {
+                "brace-expansion": "^1.1.7"
+            },
+            "engines": {
+                "node": "*"
+            }
+        },
+        "node_modules/@eslint/config-helpers": {
+            "version": "0.4.0",
+            "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.4.0.tgz",
+            "integrity": "sha512-WUFvV4WoIwW8Bv0KeKCIIEgdSiFOsulyN0xrMu+7z43q/hkOLXjvb5u7UC9jDxvRzcrbEmuZBX5yJZz1741jog==",
+            "dev": true,
+            "license": "Apache-2.0",
+            "dependencies": {
+                "@eslint/core": "^0.16.0"
+            },
+            "engines": {
+                "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+            }
+        },
+        "node_modules/@eslint/core": {
+            "version": "0.16.0",
+            "resolved": "https://registry.npmjs.org/@eslint/core/-/core-0.16.0.tgz",
+            "integrity": "sha512-nmC8/totwobIiFcGkDza3GIKfAw1+hLiYVrh3I1nIomQ8PEr5cxg34jnkmGawul/ep52wGRAcyeDCNtWKSOj4Q==",
+            "dev": true,
+            "license": "Apache-2.0",
+            "dependencies": {
+                "@types/json-schema": "^7.0.15"
+            },
+            "engines": {
+                "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+            }
+        },
+        "node_modules/@eslint/eslintrc": {
+            "version": "3.3.1",
+            "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.3.1.tgz",
+            "integrity": "sha512-gtF186CXhIl1p4pJNGZw8Yc6RlshoePRvE0X91oPGb3vZ8pM3qOS9W9NGPat9LziaBV7XrJWGylNQXkGcnM3IQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "ajv": "^6.12.4",
+                "debug": "^4.3.2",
+                "espree": "^10.0.1",
+                "globals": "^14.0.0",
+                "ignore": "^5.2.0",
+                "import-fresh": "^3.2.1",
+                "js-yaml": "^4.1.0",
+                "minimatch": "^3.1.2",
+                "strip-json-comments": "^3.1.1"
+            },
+            "engines": {
+                "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+            },
+            "funding": {
+                "url": "https://opencollective.com/eslint"
+            }
+        },
+        "node_modules/@eslint/eslintrc/node_modules/brace-expansion": {
+            "version": "1.1.12",
+            "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
+            "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "balanced-match": "^1.0.0",
+                "concat-map": "0.0.1"
+            }
+        },
+        "node_modules/@eslint/eslintrc/node_modules/globals": {
+            "version": "14.0.0",
+            "resolved": "https://registry.npmjs.org/globals/-/globals-14.0.0.tgz",
+            "integrity": "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=18"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
+        "node_modules/@eslint/eslintrc/node_modules/ignore": {
+            "version": "5.3.2",
+            "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
+            "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">= 4"
+            }
+        },
+        "node_modules/@eslint/eslintrc/node_modules/minimatch": {
+            "version": "3.1.2",
+            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+            "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+            "dev": true,
+            "license": "ISC",
+            "dependencies": {
+                "brace-expansion": "^1.1.7"
+            },
+            "engines": {
+                "node": "*"
+            }
+        },
+        "node_modules/@eslint/js": {
+            "version": "9.37.0",
+            "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.37.0.tgz",
+            "integrity": "sha512-jaS+NJ+hximswBG6pjNX0uEJZkrT0zwpVi3BA3vX22aFGjJjmgSTSmPpZCRKmoBL5VY/M6p0xsSJx7rk7sy5gg==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+            },
+            "funding": {
+                "url": "https://eslint.org/donate"
+            }
+        },
+        "node_modules/@eslint/object-schema": {
+            "version": "2.1.6",
+            "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-2.1.6.tgz",
+            "integrity": "sha512-RBMg5FRL0I0gs51M/guSAj5/e14VQ4tpZnQNWwuDT66P14I43ItmPfIZRhO9fUVIPOAQXU47atlywZ/czoqFPA==",
+            "dev": true,
+            "license": "Apache-2.0",
+            "engines": {
+                "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+            }
+        },
+        "node_modules/@eslint/plugin-kit": {
+            "version": "0.4.0",
+            "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.4.0.tgz",
+            "integrity": "sha512-sB5uyeq+dwCWyPi31B2gQlVlo+j5brPlWx4yZBrEaRo/nhdDE8Xke1gsGgtiBdaBTxuTkceLVuVt/pclrasb0A==",
+            "dev": true,
+            "license": "Apache-2.0",
+            "dependencies": {
+                "@eslint/core": "^0.16.0",
+                "levn": "^0.4.1"
+            },
+            "engines": {
+                "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+            }
+        },
+        "node_modules/@humanfs/core": {
+            "version": "0.19.1",
+            "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.1.tgz",
+            "integrity": "sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==",
+            "dev": true,
+            "license": "Apache-2.0",
+            "engines": {
+                "node": ">=18.18.0"
+            }
+        },
+        "node_modules/@humanfs/node": {
+            "version": "0.16.7",
+            "resolved": "https://registry.npmjs.org/@humanfs/node/-/node-0.16.7.tgz",
+            "integrity": "sha512-/zUx+yOsIrG4Y43Eh2peDeKCxlRt/gET6aHfaKpuq267qXdYDFViVHfMaLyygZOnl0kGWxFIgsBy8QFuTLUXEQ==",
+            "dev": true,
+            "license": "Apache-2.0",
+            "dependencies": {
+                "@humanfs/core": "^0.19.1",
+                "@humanwhocodes/retry": "^0.4.0"
+            },
+            "engines": {
+                "node": ">=18.18.0"
+            }
+        },
+        "node_modules/@humanwhocodes/module-importer": {
+            "version": "1.0.1",
+            "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz",
+            "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==",
+            "dev": true,
+            "license": "Apache-2.0",
+            "engines": {
+                "node": ">=12.22"
+            },
+            "funding": {
+                "type": "github",
+                "url": "https://github.com/sponsors/nzakas"
+            }
+        },
+        "node_modules/@humanwhocodes/retry": {
+            "version": "0.4.3",
+            "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.4.3.tgz",
+            "integrity": "sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==",
+            "dev": true,
+            "license": "Apache-2.0",
+            "engines": {
+                "node": ">=18.18"
+            },
+            "funding": {
+                "type": "github",
+                "url": "https://github.com/sponsors/nzakas"
+            }
+        },
+        "node_modules/@napi-rs/wasm-runtime": {
+            "version": "0.2.12",
+            "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-0.2.12.tgz",
+            "integrity": "sha512-ZVWUcfwY4E/yPitQJl481FjFo3K22D6qF0DuFH6Y/nbnE11GY5uguDxZMGXPQ8WQ0128MXQD7TnfHyK4oWoIJQ==",
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "dependencies": {
+                "@emnapi/core": "^1.4.3",
+                "@emnapi/runtime": "^1.4.3",
+                "@tybys/wasm-util": "^0.10.0"
+            }
+        },
+        "node_modules/@nodelib/fs.scandir": {
+            "version": "2.1.5",
+            "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
+            "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@nodelib/fs.stat": "2.0.5",
+                "run-parallel": "^1.1.9"
+            },
+            "engines": {
+                "node": ">= 8"
+            }
+        },
+        "node_modules/@nodelib/fs.stat": {
+            "version": "2.0.5",
+            "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz",
+            "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">= 8"
+            }
+        },
+        "node_modules/@nodelib/fs.walk": {
+            "version": "1.2.8",
+            "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz",
+            "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@nodelib/fs.scandir": "2.1.5",
+                "fastq": "^1.6.0"
+            },
+            "engines": {
+                "node": ">= 8"
+            }
+        },
+        "node_modules/@playwright/test": {
+            "version": "1.55.0",
+            "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.55.0.tgz",
+            "integrity": "sha512-04IXzPwHrW69XusN/SIdDdKZBzMfOT9UNT/YiJit/xpy2VuAoB8NHc8Aplb96zsWDddLnbkPL3TsmrS04ZU2xQ==",
+            "dev": true,
+            "license": "Apache-2.0",
+            "dependencies": {
+                "playwright": "1.55.0"
+            },
+            "bin": {
+                "playwright": "cli.js"
+            },
+            "engines": {
+                "node": ">=18"
+            }
+        },
+        "node_modules/@rtsao/scc": {
+            "version": "1.1.0",
+            "resolved": "https://registry.npmjs.org/@rtsao/scc/-/scc-1.1.0.tgz",
+            "integrity": "sha512-zt6OdqaDoOnJ1ZYsCYGt9YmWzDXl4vQdKTyJev62gFhRGKdx7mcT54V9KIjg+d2wi9EXsPvAPKe7i7WjfVWB8g==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/@tybys/wasm-util": {
+            "version": "0.10.0",
+            "resolved": "https://registry.npmjs.org/@tybys/wasm-util/-/wasm-util-0.10.0.tgz",
+            "integrity": "sha512-VyyPYFlOMNylG45GoAe0xDoLwWuowvf92F9kySqzYh8vmYm7D2u4iUJKa1tOUpS70Ku13ASrOkS4ScXFsTaCNQ==",
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "dependencies": {
+                "tslib": "^2.4.0"
+            }
+        },
+        "node_modules/@types/estree": {
+            "version": "1.0.8",
+            "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
+            "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/@types/json-schema": {
+            "version": "7.0.15",
+            "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",
+            "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/@types/json5": {
+            "version": "0.0.29",
+            "resolved": "https://registry.npmjs.org/@types/json5/-/json5-0.0.29.tgz",
+            "integrity": "sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/@typescript-eslint/eslint-plugin": {
+            "version": "8.46.1",
+            "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.46.1.tgz",
+            "integrity": "sha512-rUsLh8PXmBjdiPY+Emjz9NX2yHvhS11v0SR6xNJkm5GM1MO9ea/1GoDKlHHZGrOJclL/cZ2i/vRUYVtjRhrHVQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@eslint-community/regexpp": "^4.10.0",
+                "@typescript-eslint/scope-manager": "8.46.1",
+                "@typescript-eslint/type-utils": "8.46.1",
+                "@typescript-eslint/utils": "8.46.1",
+                "@typescript-eslint/visitor-keys": "8.46.1",
+                "graphemer": "^1.4.0",
+                "ignore": "^7.0.0",
+                "natural-compare": "^1.4.0",
+                "ts-api-utils": "^2.1.0"
+            },
+            "engines": {
+                "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+            },
+            "funding": {
+                "type": "opencollective",
+                "url": "https://opencollective.com/typescript-eslint"
+            },
+            "peerDependencies": {
+                "@typescript-eslint/parser": "^8.46.1",
+                "eslint": "^8.57.0 || ^9.0.0",
+                "typescript": ">=4.8.4 <6.0.0"
+            }
+        },
+        "node_modules/@typescript-eslint/parser": {
+            "version": "8.46.1",
+            "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.46.1.tgz",
+            "integrity": "sha512-6JSSaBZmsKvEkbRUkf7Zj7dru/8ZCrJxAqArcLaVMee5907JdtEbKGsZ7zNiIm/UAkpGUkaSMZEXShnN2D1HZA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@typescript-eslint/scope-manager": "8.46.1",
+                "@typescript-eslint/types": "8.46.1",
+                "@typescript-eslint/typescript-estree": "8.46.1",
+                "@typescript-eslint/visitor-keys": "8.46.1",
+                "debug": "^4.3.4"
+            },
+            "engines": {
+                "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+            },
+            "funding": {
+                "type": "opencollective",
+                "url": "https://opencollective.com/typescript-eslint"
+            },
+            "peerDependencies": {
+                "eslint": "^8.57.0 || ^9.0.0",
+                "typescript": ">=4.8.4 <6.0.0"
+            }
+        },
+        "node_modules/@typescript-eslint/project-service": {
+            "version": "8.46.1",
+            "resolved": "https://registry.npmjs.org/@typescript-eslint/project-service/-/project-service-8.46.1.tgz",
+            "integrity": "sha512-FOIaFVMHzRskXr5J4Jp8lFVV0gz5ngv3RHmn+E4HYxSJ3DgDzU7fVI1/M7Ijh1zf6S7HIoaIOtln1H5y8V+9Zg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@typescript-eslint/tsconfig-utils": "^8.46.1",
+                "@typescript-eslint/types": "^8.46.1",
+                "debug": "^4.3.4"
+            },
+            "engines": {
+                "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+            },
+            "funding": {
+                "type": "opencollective",
+                "url": "https://opencollective.com/typescript-eslint"
+            },
+            "peerDependencies": {
+                "typescript": ">=4.8.4 <6.0.0"
+            }
+        },
+        "node_modules/@typescript-eslint/scope-manager": {
+            "version": "8.46.1",
+            "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.46.1.tgz",
+            "integrity": "sha512-weL9Gg3/5F0pVQKiF8eOXFZp8emqWzZsOJuWRUNtHT+UNV2xSJegmpCNQHy37aEQIbToTq7RHKhWvOsmbM680A==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@typescript-eslint/types": "8.46.1",
+                "@typescript-eslint/visitor-keys": "8.46.1"
+            },
+            "engines": {
+                "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+            },
+            "funding": {
+                "type": "opencollective",
+                "url": "https://opencollective.com/typescript-eslint"
+            }
+        },
+        "node_modules/@typescript-eslint/tsconfig-utils": {
+            "version": "8.46.1",
+            "resolved": "https://registry.npmjs.org/@typescript-eslint/tsconfig-utils/-/tsconfig-utils-8.46.1.tgz",
+            "integrity": "sha512-X88+J/CwFvlJB+mK09VFqx5FE4H5cXD+H/Bdza2aEWkSb8hnWIQorNcscRl4IEo1Cz9VI/+/r/jnGWkbWPx54g==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+            },
+            "funding": {
+                "type": "opencollective",
+                "url": "https://opencollective.com/typescript-eslint"
+            },
+            "peerDependencies": {
+                "typescript": ">=4.8.4 <6.0.0"
+            }
+        },
+        "node_modules/@typescript-eslint/type-utils": {
+            "version": "8.46.1",
+            "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.46.1.tgz",
+            "integrity": "sha512-+BlmiHIiqufBxkVnOtFwjah/vrkF4MtKKvpXrKSPLCkCtAp8H01/VV43sfqA98Od7nJpDcFnkwgyfQbOG0AMvw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@typescript-eslint/types": "8.46.1",
+                "@typescript-eslint/typescript-estree": "8.46.1",
+                "@typescript-eslint/utils": "8.46.1",
+                "debug": "^4.3.4",
+                "ts-api-utils": "^2.1.0"
+            },
+            "engines": {
+                "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+            },
+            "funding": {
+                "type": "opencollective",
+                "url": "https://opencollective.com/typescript-eslint"
+            },
+            "peerDependencies": {
+                "eslint": "^8.57.0 || ^9.0.0",
+                "typescript": ">=4.8.4 <6.0.0"
+            }
+        },
+        "node_modules/@typescript-eslint/types": {
+            "version": "8.46.1",
+            "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.46.1.tgz",
+            "integrity": "sha512-C+soprGBHwWBdkDpbaRC4paGBrkIXxVlNohadL5o0kfhsXqOC6GYH2S/Obmig+I0HTDl8wMaRySwrfrXVP8/pQ==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+            },
+            "funding": {
+                "type": "opencollective",
+                "url": "https://opencollective.com/typescript-eslint"
+            }
+        },
+        "node_modules/@typescript-eslint/typescript-estree": {
+            "version": "8.46.1",
+            "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.46.1.tgz",
+            "integrity": "sha512-uIifjT4s8cQKFQ8ZBXXyoUODtRoAd7F7+G8MKmtzj17+1UbdzFl52AzRyZRyKqPHhgzvXunnSckVu36flGy8cg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@typescript-eslint/project-service": "8.46.1",
+                "@typescript-eslint/tsconfig-utils": "8.46.1",
+                "@typescript-eslint/types": "8.46.1",
+                "@typescript-eslint/visitor-keys": "8.46.1",
+                "debug": "^4.3.4",
+                "fast-glob": "^3.3.2",
+                "is-glob": "^4.0.3",
+                "minimatch": "^9.0.4",
+                "semver": "^7.6.0",
+                "ts-api-utils": "^2.1.0"
+            },
+            "engines": {
+                "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+            },
+            "funding": {
+                "type": "opencollective",
+                "url": "https://opencollective.com/typescript-eslint"
+            },
+            "peerDependencies": {
+                "typescript": ">=4.8.4 <6.0.0"
+            }
+        },
+        "node_modules/@typescript-eslint/utils": {
+            "version": "8.46.1",
+            "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.46.1.tgz",
+            "integrity": "sha512-vkYUy6LdZS7q1v/Gxb2Zs7zziuXN0wxqsetJdeZdRe/f5dwJFglmuvZBfTUivCtjH725C1jWCDfpadadD95EDQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@eslint-community/eslint-utils": "^4.7.0",
+                "@typescript-eslint/scope-manager": "8.46.1",
+                "@typescript-eslint/types": "8.46.1",
+                "@typescript-eslint/typescript-estree": "8.46.1"
+            },
+            "engines": {
+                "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+            },
+            "funding": {
+                "type": "opencollective",
+                "url": "https://opencollective.com/typescript-eslint"
+            },
+            "peerDependencies": {
+                "eslint": "^8.57.0 || ^9.0.0",
+                "typescript": ">=4.8.4 <6.0.0"
+            }
+        },
+        "node_modules/@typescript-eslint/visitor-keys": {
+            "version": "8.46.1",
+            "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.46.1.tgz",
+            "integrity": "sha512-ptkmIf2iDkNUjdeu2bQqhFPV1m6qTnFFjg7PPDjxKWaMaP0Z6I9l30Jr3g5QqbZGdw8YdYvLp+XnqnWWZOg/NA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@typescript-eslint/types": "8.46.1",
+                "eslint-visitor-keys": "^4.2.1"
+            },
+            "engines": {
+                "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+            },
+            "funding": {
+                "type": "opencollective",
+                "url": "https://opencollective.com/typescript-eslint"
+            }
+        },
+        "node_modules/@typescript-eslint/visitor-keys/node_modules/eslint-visitor-keys": {
+            "version": "4.2.1",
+            "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.1.tgz",
+            "integrity": "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==",
+            "dev": true,
+            "license": "Apache-2.0",
+            "engines": {
+                "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+            },
+            "funding": {
+                "url": "https://opencollective.com/eslint"
+            }
+        },
+        "node_modules/@unrs/resolver-binding-android-arm-eabi": {
+            "version": "1.11.1",
+            "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-android-arm-eabi/-/resolver-binding-android-arm-eabi-1.11.1.tgz",
+            "integrity": "sha512-ppLRUgHVaGRWUx0R0Ut06Mjo9gBaBkg3v/8AxusGLhsIotbBLuRk51rAzqLC8gq6NyyAojEXglNjzf6R948DNw==",
+            "cpu": [
+                "arm"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "android"
+            ]
+        },
+        "node_modules/@unrs/resolver-binding-android-arm64": {
+            "version": "1.11.1",
+            "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-android-arm64/-/resolver-binding-android-arm64-1.11.1.tgz",
+            "integrity": "sha512-lCxkVtb4wp1v+EoN+HjIG9cIIzPkX5OtM03pQYkG+U5O/wL53LC4QbIeazgiKqluGeVEeBlZahHalCaBvU1a2g==",
+            "cpu": [
+                "arm64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "android"
+            ]
+        },
+        "node_modules/@unrs/resolver-binding-darwin-arm64": {
+            "version": "1.11.1",
+            "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-darwin-arm64/-/resolver-binding-darwin-arm64-1.11.1.tgz",
+            "integrity": "sha512-gPVA1UjRu1Y/IsB/dQEsp2V1pm44Of6+LWvbLc9SDk1c2KhhDRDBUkQCYVWe6f26uJb3fOK8saWMgtX8IrMk3g==",
+            "cpu": [
+                "arm64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "darwin"
+            ]
+        },
+        "node_modules/@unrs/resolver-binding-darwin-x64": {
+            "version": "1.11.1",
+            "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-darwin-x64/-/resolver-binding-darwin-x64-1.11.1.tgz",
+            "integrity": "sha512-cFzP7rWKd3lZaCsDze07QX1SC24lO8mPty9vdP+YVa3MGdVgPmFc59317b2ioXtgCMKGiCLxJ4HQs62oz6GfRQ==",
+            "cpu": [
+                "x64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "darwin"
+            ]
+        },
+        "node_modules/@unrs/resolver-binding-freebsd-x64": {
+            "version": "1.11.1",
+            "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-freebsd-x64/-/resolver-binding-freebsd-x64-1.11.1.tgz",
+            "integrity": "sha512-fqtGgak3zX4DCB6PFpsH5+Kmt/8CIi4Bry4rb1ho6Av2QHTREM+47y282Uqiu3ZRF5IQioJQ5qWRV6jduA+iGw==",
+            "cpu": [
+                "x64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "freebsd"
+            ]
+        },
+        "node_modules/@unrs/resolver-binding-linux-arm-gnueabihf": {
+            "version": "1.11.1",
+            "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-arm-gnueabihf/-/resolver-binding-linux-arm-gnueabihf-1.11.1.tgz",
+            "integrity": "sha512-u92mvlcYtp9MRKmP+ZvMmtPN34+/3lMHlyMj7wXJDeXxuM0Vgzz0+PPJNsro1m3IZPYChIkn944wW8TYgGKFHw==",
+            "cpu": [
+                "arm"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ]
+        },
+        "node_modules/@unrs/resolver-binding-linux-arm-musleabihf": {
+            "version": "1.11.1",
+            "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-arm-musleabihf/-/resolver-binding-linux-arm-musleabihf-1.11.1.tgz",
+            "integrity": "sha512-cINaoY2z7LVCrfHkIcmvj7osTOtm6VVT16b5oQdS4beibX2SYBwgYLmqhBjA1t51CarSaBuX5YNsWLjsqfW5Cw==",
+            "cpu": [
+                "arm"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ]
+        },
+        "node_modules/@unrs/resolver-binding-linux-arm64-gnu": {
+            "version": "1.11.1",
+            "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-arm64-gnu/-/resolver-binding-linux-arm64-gnu-1.11.1.tgz",
+            "integrity": "sha512-34gw7PjDGB9JgePJEmhEqBhWvCiiWCuXsL9hYphDF7crW7UgI05gyBAi6MF58uGcMOiOqSJ2ybEeCvHcq0BCmQ==",
+            "cpu": [
+                "arm64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ]
+        },
+        "node_modules/@unrs/resolver-binding-linux-arm64-musl": {
+            "version": "1.11.1",
+            "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-arm64-musl/-/resolver-binding-linux-arm64-musl-1.11.1.tgz",
+            "integrity": "sha512-RyMIx6Uf53hhOtJDIamSbTskA99sPHS96wxVE/bJtePJJtpdKGXO1wY90oRdXuYOGOTuqjT8ACccMc4K6QmT3w==",
+            "cpu": [
+                "arm64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ]
+        },
+        "node_modules/@unrs/resolver-binding-linux-ppc64-gnu": {
+            "version": "1.11.1",
+            "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-ppc64-gnu/-/resolver-binding-linux-ppc64-gnu-1.11.1.tgz",
+            "integrity": "sha512-D8Vae74A4/a+mZH0FbOkFJL9DSK2R6TFPC9M+jCWYia/q2einCubX10pecpDiTmkJVUH+y8K3BZClycD8nCShA==",
+            "cpu": [
+                "ppc64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ]
+        },
+        "node_modules/@unrs/resolver-binding-linux-riscv64-gnu": {
+            "version": "1.11.1",
+            "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-riscv64-gnu/-/resolver-binding-linux-riscv64-gnu-1.11.1.tgz",
+            "integrity": "sha512-frxL4OrzOWVVsOc96+V3aqTIQl1O2TjgExV4EKgRY09AJ9leZpEg8Ak9phadbuX0BA4k8U5qtvMSQQGGmaJqcQ==",
+            "cpu": [
+                "riscv64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ]
+        },
+        "node_modules/@unrs/resolver-binding-linux-riscv64-musl": {
+            "version": "1.11.1",
+            "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-riscv64-musl/-/resolver-binding-linux-riscv64-musl-1.11.1.tgz",
+            "integrity": "sha512-mJ5vuDaIZ+l/acv01sHoXfpnyrNKOk/3aDoEdLO/Xtn9HuZlDD6jKxHlkN8ZhWyLJsRBxfv9GYM2utQ1SChKew==",
+            "cpu": [
+                "riscv64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ]
+        },
+        "node_modules/@unrs/resolver-binding-linux-s390x-gnu": {
+            "version": "1.11.1",
+            "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-s390x-gnu/-/resolver-binding-linux-s390x-gnu-1.11.1.tgz",
+            "integrity": "sha512-kELo8ebBVtb9sA7rMe1Cph4QHreByhaZ2QEADd9NzIQsYNQpt9UkM9iqr2lhGr5afh885d/cB5QeTXSbZHTYPg==",
+            "cpu": [
+                "s390x"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ]
+        },
+        "node_modules/@unrs/resolver-binding-linux-x64-gnu": {
+            "version": "1.11.1",
+            "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-x64-gnu/-/resolver-binding-linux-x64-gnu-1.11.1.tgz",
+            "integrity": "sha512-C3ZAHugKgovV5YvAMsxhq0gtXuwESUKc5MhEtjBpLoHPLYM+iuwSj3lflFwK3DPm68660rZ7G8BMcwSro7hD5w==",
+            "cpu": [
+                "x64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ]
+        },
+        "node_modules/@unrs/resolver-binding-linux-x64-musl": {
+            "version": "1.11.1",
+            "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-x64-musl/-/resolver-binding-linux-x64-musl-1.11.1.tgz",
+            "integrity": "sha512-rV0YSoyhK2nZ4vEswT/QwqzqQXw5I6CjoaYMOX0TqBlWhojUf8P94mvI7nuJTeaCkkds3QE4+zS8Ko+GdXuZtA==",
+            "cpu": [
+                "x64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ]
+        },
+        "node_modules/@unrs/resolver-binding-wasm32-wasi": {
+            "version": "1.11.1",
+            "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-wasm32-wasi/-/resolver-binding-wasm32-wasi-1.11.1.tgz",
+            "integrity": "sha512-5u4RkfxJm+Ng7IWgkzi3qrFOvLvQYnPBmjmZQ8+szTK/b31fQCnleNl1GgEt7nIsZRIf5PLhPwT0WM+q45x/UQ==",
+            "cpu": [
+                "wasm32"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "dependencies": {
+                "@napi-rs/wasm-runtime": "^0.2.11"
+            },
+            "engines": {
+                "node": ">=14.0.0"
+            }
+        },
+        "node_modules/@unrs/resolver-binding-win32-arm64-msvc": {
+            "version": "1.11.1",
+            "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-win32-arm64-msvc/-/resolver-binding-win32-arm64-msvc-1.11.1.tgz",
+            "integrity": "sha512-nRcz5Il4ln0kMhfL8S3hLkxI85BXs3o8EYoattsJNdsX4YUU89iOkVn7g0VHSRxFuVMdM4Q1jEpIId1Ihim/Uw==",
+            "cpu": [
+                "arm64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "win32"
+            ]
+        },
+        "node_modules/@unrs/resolver-binding-win32-ia32-msvc": {
+            "version": "1.11.1",
+            "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-win32-ia32-msvc/-/resolver-binding-win32-ia32-msvc-1.11.1.tgz",
+            "integrity": "sha512-DCEI6t5i1NmAZp6pFonpD5m7i6aFrpofcp4LA2i8IIq60Jyo28hamKBxNrZcyOwVOZkgsRp9O2sXWBWP8MnvIQ==",
+            "cpu": [
+                "ia32"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "win32"
+            ]
+        },
+        "node_modules/@unrs/resolver-binding-win32-x64-msvc": {
+            "version": "1.11.1",
+            "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-win32-x64-msvc/-/resolver-binding-win32-x64-msvc-1.11.1.tgz",
+            "integrity": "sha512-lrW200hZdbfRtztbygyaq/6jP6AKE8qQN2KvPcJ+x7wiD038YtnYtZ82IMNJ69GJibV7bwL3y9FgK+5w/pYt6g==",
+            "cpu": [
+                "x64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "win32"
+            ]
+        },
+        "node_modules/acorn": {
+            "version": "8.15.0",
+            "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
+            "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
+            "dev": true,
+            "license": "MIT",
+            "bin": {
+                "acorn": "bin/acorn"
+            },
+            "engines": {
+                "node": ">=0.4.0"
+            }
+        },
+        "node_modules/acorn-jsx": {
+            "version": "5.3.2",
+            "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz",
+            "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==",
+            "dev": true,
+            "license": "MIT",
+            "peerDependencies": {
+                "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
+            }
+        },
+        "node_modules/ajv": {
+            "version": "6.12.6",
+            "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
+            "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "fast-deep-equal": "^3.1.1",
+                "fast-json-stable-stringify": "^2.0.0",
+                "json-schema-traverse": "^0.4.1",
+                "uri-js": "^4.2.2"
+            },
+            "funding": {
+                "type": "github",
+                "url": "https://github.com/sponsors/epoberezkin"
+            }
+        },
+        "node_modules/ansi-escapes": {
+            "version": "7.1.1",
+            "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-7.1.1.tgz",
+            "integrity": "sha512-Zhl0ErHcSRUaVfGUeUdDuLgpkEo8KIFjB4Y9uAc46ScOpdDiU1Dbyplh7qWJeJ/ZHpbyMSM26+X3BySgnIz40Q==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "environment": "^1.0.0"
+            },
+            "engines": {
+                "node": ">=18"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
+        "node_modules/ansi-regex": {
+            "version": "6.2.2",
+            "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.2.2.tgz",
+            "integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=12"
+            },
+            "funding": {
+                "url": "https://github.com/chalk/ansi-regex?sponsor=1"
+            }
+        },
+        "node_modules/ansi-styles": {
+            "version": "4.3.0",
+            "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+            "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "color-convert": "^2.0.1"
+            },
+            "engines": {
+                "node": ">=8"
+            },
+            "funding": {
+                "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+            }
+        },
+        "node_modules/argparse": {
+            "version": "2.0.1",
+            "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
+            "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
+            "dev": true,
+            "license": "Python-2.0"
+        },
+        "node_modules/array-buffer-byte-length": {
+            "version": "1.0.2",
+            "resolved": "https://registry.npmjs.org/array-buffer-byte-length/-/array-buffer-byte-length-1.0.2.tgz",
+            "integrity": "sha512-LHE+8BuR7RYGDKvnrmcuSq3tDcKv9OFEXQt/HpbZhY7V6h0zlUXutnAD82GiFx9rdieCMjkvtcsPqBwgUl1Iiw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bound": "^1.0.3",
+                "is-array-buffer": "^3.0.5"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/array-includes": {
+            "version": "3.1.9",
+            "resolved": "https://registry.npmjs.org/array-includes/-/array-includes-3.1.9.tgz",
+            "integrity": "sha512-FmeCCAenzH0KH381SPT5FZmiA/TmpndpcaShhfgEN9eCVjnFBqq3l1xrI42y8+PPLI6hypzou4GXw00WHmPBLQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bind": "^1.0.8",
+                "call-bound": "^1.0.4",
+                "define-properties": "^1.2.1",
+                "es-abstract": "^1.24.0",
+                "es-object-atoms": "^1.1.1",
+                "get-intrinsic": "^1.3.0",
+                "is-string": "^1.1.1",
+                "math-intrinsics": "^1.1.0"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/array.prototype.findlast": {
+            "version": "1.2.5",
+            "resolved": "https://registry.npmjs.org/array.prototype.findlast/-/array.prototype.findlast-1.2.5.tgz",
+            "integrity": "sha512-CVvd6FHg1Z3POpBLxO6E6zr+rSKEQ9L6rZHAaY7lLfhKsWYUBBOuMs0e9o24oopj6H+geRCX0YJ+TJLBK2eHyQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bind": "^1.0.7",
+                "define-properties": "^1.2.1",
+                "es-abstract": "^1.23.2",
+                "es-errors": "^1.3.0",
+                "es-object-atoms": "^1.0.0",
+                "es-shim-unscopables": "^1.0.2"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/array.prototype.findlastindex": {
+            "version": "1.2.6",
+            "resolved": "https://registry.npmjs.org/array.prototype.findlastindex/-/array.prototype.findlastindex-1.2.6.tgz",
+            "integrity": "sha512-F/TKATkzseUExPlfvmwQKGITM3DGTK+vkAsCZoDc5daVygbJBnjEUCbgkAvVFsgfXfX4YIqZ/27G3k3tdXrTxQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bind": "^1.0.8",
+                "call-bound": "^1.0.4",
+                "define-properties": "^1.2.1",
+                "es-abstract": "^1.23.9",
+                "es-errors": "^1.3.0",
+                "es-object-atoms": "^1.1.1",
+                "es-shim-unscopables": "^1.1.0"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/array.prototype.flat": {
+            "version": "1.3.3",
+            "resolved": "https://registry.npmjs.org/array.prototype.flat/-/array.prototype.flat-1.3.3.tgz",
+            "integrity": "sha512-rwG/ja1neyLqCuGZ5YYrznA62D4mZXg0i1cIskIUKSiqF3Cje9/wXAls9B9s1Wa2fomMsIv8czB8jZcPmxCXFg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bind": "^1.0.8",
+                "define-properties": "^1.2.1",
+                "es-abstract": "^1.23.5",
+                "es-shim-unscopables": "^1.0.2"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/array.prototype.flatmap": {
+            "version": "1.3.3",
+            "resolved": "https://registry.npmjs.org/array.prototype.flatmap/-/array.prototype.flatmap-1.3.3.tgz",
+            "integrity": "sha512-Y7Wt51eKJSyi80hFrJCePGGNo5ktJCslFuboqJsbf57CCPcm5zztluPlc4/aD8sWsKvlwatezpV4U1efk8kpjg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bind": "^1.0.8",
+                "define-properties": "^1.2.1",
+                "es-abstract": "^1.23.5",
+                "es-shim-unscopables": "^1.0.2"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/array.prototype.tosorted": {
+            "version": "1.1.4",
+            "resolved": "https://registry.npmjs.org/array.prototype.tosorted/-/array.prototype.tosorted-1.1.4.tgz",
+            "integrity": "sha512-p6Fx8B7b7ZhL/gmUsAy0D15WhvDccw3mnGNbZpi3pmeJdxtWsj2jEaI4Y6oo3XiHfzuSgPwKc04MYt6KgvC/wA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bind": "^1.0.7",
+                "define-properties": "^1.2.1",
+                "es-abstract": "^1.23.3",
+                "es-errors": "^1.3.0",
+                "es-shim-unscopables": "^1.0.2"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            }
+        },
+        "node_modules/arraybuffer.prototype.slice": {
+            "version": "1.0.4",
+            "resolved": "https://registry.npmjs.org/arraybuffer.prototype.slice/-/arraybuffer.prototype.slice-1.0.4.tgz",
+            "integrity": "sha512-BNoCY6SXXPQ7gF2opIP4GBE+Xw7U+pHMYKuzjgCN3GwiaIR09UUeKfheyIry77QtrCBlC0KK0q5/TER/tYh3PQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "array-buffer-byte-length": "^1.0.1",
+                "call-bind": "^1.0.8",
+                "define-properties": "^1.2.1",
+                "es-abstract": "^1.23.5",
+                "es-errors": "^1.3.0",
+                "get-intrinsic": "^1.2.6",
+                "is-array-buffer": "^3.0.4"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/async-function": {
+            "version": "1.0.0",
+            "resolved": "https://registry.npmjs.org/async-function/-/async-function-1.0.0.tgz",
+            "integrity": "sha512-hsU18Ae8CDTR6Kgu9DYf0EbCr/a5iGL0rytQDobUcdpYOKokk8LEjVphnXkDkgpi0wYVsqrXuP0bZxJaTqdgoA==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">= 0.4"
+            }
+        },
+        "node_modules/available-typed-arrays": {
+            "version": "1.0.7",
+            "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.7.tgz",
+            "integrity": "sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "possible-typed-array-names": "^1.0.0"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/balanced-match": {
+            "version": "1.0.2",
+            "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+            "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/brace-expansion": {
+            "version": "2.0.2",
+            "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz",
+            "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "balanced-match": "^1.0.0"
+            }
+        },
+        "node_modules/braces": {
+            "version": "3.0.3",
+            "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
+            "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "fill-range": "^7.1.1"
+            },
+            "engines": {
+                "node": ">=8"
+            }
+        },
+        "node_modules/call-bind": {
+            "version": "1.0.8",
+            "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.8.tgz",
+            "integrity": "sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bind-apply-helpers": "^1.0.0",
+                "es-define-property": "^1.0.0",
+                "get-intrinsic": "^1.2.4",
+                "set-function-length": "^1.2.2"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/call-bind-apply-helpers": {
+            "version": "1.0.2",
+            "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+            "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "es-errors": "^1.3.0",
+                "function-bind": "^1.1.2"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            }
+        },
+        "node_modules/call-bound": {
+            "version": "1.0.4",
+            "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz",
+            "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bind-apply-helpers": "^1.0.2",
+                "get-intrinsic": "^1.3.0"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/callsites": {
+            "version": "3.1.0",
+            "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
+            "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=6"
+            }
+        },
+        "node_modules/chalk": {
+            "version": "4.1.2",
+            "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
+            "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "ansi-styles": "^4.1.0",
+                "supports-color": "^7.1.0"
+            },
+            "engines": {
+                "node": ">=10"
+            },
+            "funding": {
+                "url": "https://github.com/chalk/chalk?sponsor=1"
+            }
+        },
+        "node_modules/cli-cursor": {
+            "version": "5.0.0",
+            "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-5.0.0.tgz",
+            "integrity": "sha512-aCj4O5wKyszjMmDT4tZj93kxyydN/K5zPWSCe6/0AV/AA1pqe5ZBIw0a2ZfPQV7lL5/yb5HsUreJ6UFAF1tEQw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "restore-cursor": "^5.0.0"
+            },
+            "engines": {
+                "node": ">=18"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
+        "node_modules/cli-truncate": {
+            "version": "5.1.0",
+            "resolved": "https://registry.npmjs.org/cli-truncate/-/cli-truncate-5.1.0.tgz",
+            "integrity": "sha512-7JDGG+4Zp0CsknDCedl0DYdaeOhc46QNpXi3NLQblkZpXXgA6LncLDUUyvrjSvZeF3VRQa+KiMGomazQrC1V8g==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "slice-ansi": "^7.1.0",
+                "string-width": "^8.0.0"
+            },
+            "engines": {
+                "node": ">=20"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
+        "node_modules/color-convert": {
+            "version": "2.0.1",
+            "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+            "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "color-name": "~1.1.4"
+            },
+            "engines": {
+                "node": ">=7.0.0"
+            }
+        },
+        "node_modules/color-name": {
+            "version": "1.1.4",
+            "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+            "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/colorette": {
+            "version": "2.0.20",
+            "resolved": "https://registry.npmjs.org/colorette/-/colorette-2.0.20.tgz",
+            "integrity": "sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/commander": {
+            "version": "14.0.1",
+            "resolved": "https://registry.npmjs.org/commander/-/commander-14.0.1.tgz",
+            "integrity": "sha512-2JkV3gUZUVrbNA+1sjBOYLsMZ5cEEl8GTFP2a4AVz5hvasAMCQ1D2l2le/cX+pV4N6ZU17zjUahLpIXRrnWL8A==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=20"
+            }
+        },
+        "node_modules/concat-map": {
+            "version": "0.0.1",
+            "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+            "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/cross-spawn": {
+            "version": "7.0.6",
+            "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+            "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "path-key": "^3.1.0",
+                "shebang-command": "^2.0.0",
+                "which": "^2.0.1"
+            },
+            "engines": {
+                "node": ">= 8"
+            }
+        },
+        "node_modules/data-view-buffer": {
+            "version": "1.0.2",
+            "resolved": "https://registry.npmjs.org/data-view-buffer/-/data-view-buffer-1.0.2.tgz",
+            "integrity": "sha512-EmKO5V3OLXh1rtK2wgXRansaK1/mtVdTUEiEI0W8RkvgT05kfxaH29PliLnpLP73yYO6142Q72QNa8Wx/A5CqQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bound": "^1.0.3",
+                "es-errors": "^1.3.0",
+                "is-data-view": "^1.0.2"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/data-view-byte-length": {
+            "version": "1.0.2",
+            "resolved": "https://registry.npmjs.org/data-view-byte-length/-/data-view-byte-length-1.0.2.tgz",
+            "integrity": "sha512-tuhGbE6CfTM9+5ANGf+oQb72Ky/0+s3xKUpHvShfiz2RxMFgFPjsXuRLBVMtvMs15awe45SRb83D6wH4ew6wlQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bound": "^1.0.3",
+                "es-errors": "^1.3.0",
+                "is-data-view": "^1.0.2"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/inspect-js"
+            }
+        },
+        "node_modules/data-view-byte-offset": {
+            "version": "1.0.1",
+            "resolved": "https://registry.npmjs.org/data-view-byte-offset/-/data-view-byte-offset-1.0.1.tgz",
+            "integrity": "sha512-BS8PfmtDGnrgYdOonGZQdLZslWIeCGFP9tpan0hi1Co2Zr2NKADsvGYA8XxuG/4UWgJ6Cjtv+YJnB6MM69QGlQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bound": "^1.0.2",
+                "es-errors": "^1.3.0",
+                "is-data-view": "^1.0.1"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/debug": {
+            "version": "4.4.1",
+            "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+            "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "ms": "^2.1.3"
+            },
+            "engines": {
+                "node": ">=6.0"
+            },
+            "peerDependenciesMeta": {
+                "supports-color": {
+                    "optional": true
+                }
+            }
+        },
+        "node_modules/deep-is": {
+            "version": "0.1.4",
+            "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
+            "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/define-data-property": {
+            "version": "1.1.4",
+            "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz",
+            "integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "es-define-property": "^1.0.0",
+                "es-errors": "^1.3.0",
+                "gopd": "^1.0.1"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/define-properties": {
+            "version": "1.2.1",
+            "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.1.tgz",
+            "integrity": "sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "define-data-property": "^1.0.1",
+                "has-property-descriptors": "^1.0.0",
+                "object-keys": "^1.1.1"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/dotenv": {
+            "version": "17.2.2",
+            "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-17.2.2.tgz",
+            "integrity": "sha512-Sf2LSQP+bOlhKWWyhFsn0UsfdK/kCWRv1iuA2gXAwt3dyNabr6QSj00I2V10pidqz69soatm9ZwZvpQMTIOd5Q==",
+            "dev": true,
+            "license": "BSD-2-Clause",
+            "engines": {
+                "node": ">=12"
+            },
+            "funding": {
+                "url": "https://dotenvx.com"
+            }
+        },
+        "node_modules/dunder-proto": {
+            "version": "1.0.1",
+            "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+            "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bind-apply-helpers": "^1.0.1",
+                "es-errors": "^1.3.0",
+                "gopd": "^1.2.0"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            }
+        },
+        "node_modules/emoji-regex": {
+            "version": "10.6.0",
+            "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-10.6.0.tgz",
+            "integrity": "sha512-toUI84YS5YmxW219erniWD0CIVOo46xGKColeNQRgOzDorgBi1v4D71/OFzgD9GO2UGKIv1C3Sp8DAn0+j5w7A==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/environment": {
+            "version": "1.1.0",
+            "resolved": "https://registry.npmjs.org/environment/-/environment-1.1.0.tgz",
+            "integrity": "sha512-xUtoPkMggbz0MPyPiIWr1Kp4aeWJjDZ6SMvURhimjdZgsRuDplF5/s9hcgGhyXMhs+6vpnuoiZ2kFiu3FMnS8Q==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=18"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
+        "node_modules/es-abstract": {
+            "version": "1.24.0",
+            "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.24.0.tgz",
+            "integrity": "sha512-WSzPgsdLtTcQwm4CROfS5ju2Wa1QQcVeT37jFjYzdFz1r9ahadC8B8/a4qxJxM+09F18iumCdRmlr96ZYkQvEg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "array-buffer-byte-length": "^1.0.2",
+                "arraybuffer.prototype.slice": "^1.0.4",
+                "available-typed-arrays": "^1.0.7",
+                "call-bind": "^1.0.8",
+                "call-bound": "^1.0.4",
+                "data-view-buffer": "^1.0.2",
+                "data-view-byte-length": "^1.0.2",
+                "data-view-byte-offset": "^1.0.1",
+                "es-define-property": "^1.0.1",
+                "es-errors": "^1.3.0",
+                "es-object-atoms": "^1.1.1",
+                "es-set-tostringtag": "^2.1.0",
+                "es-to-primitive": "^1.3.0",
+                "function.prototype.name": "^1.1.8",
+                "get-intrinsic": "^1.3.0",
+                "get-proto": "^1.0.1",
+                "get-symbol-description": "^1.1.0",
+                "globalthis": "^1.0.4",
+                "gopd": "^1.2.0",
+                "has-property-descriptors": "^1.0.2",
+                "has-proto": "^1.2.0",
+                "has-symbols": "^1.1.0",
+                "hasown": "^2.0.2",
+                "internal-slot": "^1.1.0",
+                "is-array-buffer": "^3.0.5",
+                "is-callable": "^1.2.7",
+                "is-data-view": "^1.0.2",
+                "is-negative-zero": "^2.0.3",
+                "is-regex": "^1.2.1",
+                "is-set": "^2.0.3",
+                "is-shared-array-buffer": "^1.0.4",
+                "is-string": "^1.1.1",
+                "is-typed-array": "^1.1.15",
+                "is-weakref": "^1.1.1",
+                "math-intrinsics": "^1.1.0",
+                "object-inspect": "^1.13.4",
+                "object-keys": "^1.1.1",
+                "object.assign": "^4.1.7",
+                "own-keys": "^1.0.1",
+                "regexp.prototype.flags": "^1.5.4",
+                "safe-array-concat": "^1.1.3",
+                "safe-push-apply": "^1.0.0",
+                "safe-regex-test": "^1.1.0",
+                "set-proto": "^1.0.0",
+                "stop-iteration-iterator": "^1.1.0",
+                "string.prototype.trim": "^1.2.10",
+                "string.prototype.trimend": "^1.0.9",
+                "string.prototype.trimstart": "^1.0.8",
+                "typed-array-buffer": "^1.0.3",
+                "typed-array-byte-length": "^1.0.3",
+                "typed-array-byte-offset": "^1.0.4",
+                "typed-array-length": "^1.0.7",
+                "unbox-primitive": "^1.1.0",
+                "which-typed-array": "^1.1.19"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/es-define-property": {
+            "version": "1.0.1",
+            "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+            "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">= 0.4"
+            }
+        },
+        "node_modules/es-errors": {
+            "version": "1.3.0",
+            "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+            "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">= 0.4"
+            }
+        },
+        "node_modules/es-iterator-helpers": {
+            "version": "1.2.1",
+            "resolved": "https://registry.npmjs.org/es-iterator-helpers/-/es-iterator-helpers-1.2.1.tgz",
+            "integrity": "sha512-uDn+FE1yrDzyC0pCo961B2IHbdM8y/ACZsKD4dG6WqrjV53BADjwa7D+1aom2rsNVfLyDgU/eigvlJGJ08OQ4w==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bind": "^1.0.8",
+                "call-bound": "^1.0.3",
+                "define-properties": "^1.2.1",
+                "es-abstract": "^1.23.6",
+                "es-errors": "^1.3.0",
+                "es-set-tostringtag": "^2.0.3",
+                "function-bind": "^1.1.2",
+                "get-intrinsic": "^1.2.6",
+                "globalthis": "^1.0.4",
+                "gopd": "^1.2.0",
+                "has-property-descriptors": "^1.0.2",
+                "has-proto": "^1.2.0",
+                "has-symbols": "^1.1.0",
+                "internal-slot": "^1.1.0",
+                "iterator.prototype": "^1.1.4",
+                "safe-array-concat": "^1.1.3"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            }
+        },
+        "node_modules/es-object-atoms": {
+            "version": "1.1.1",
+            "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
+            "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "es-errors": "^1.3.0"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            }
+        },
+        "node_modules/es-set-tostringtag": {
+            "version": "2.1.0",
+            "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
+            "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "es-errors": "^1.3.0",
+                "get-intrinsic": "^1.2.6",
+                "has-tostringtag": "^1.0.2",
+                "hasown": "^2.0.2"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            }
+        },
+        "node_modules/es-shim-unscopables": {
+            "version": "1.1.0",
+            "resolved": "https://registry.npmjs.org/es-shim-unscopables/-/es-shim-unscopables-1.1.0.tgz",
+            "integrity": "sha512-d9T8ucsEhh8Bi1woXCf+TIKDIROLG5WCkxg8geBCbvk22kzwC5G2OnXVMO6FUsvQlgUUXQ2itephWDLqDzbeCw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "hasown": "^2.0.2"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            }
+        },
+        "node_modules/es-to-primitive": {
+            "version": "1.3.0",
+            "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.3.0.tgz",
+            "integrity": "sha512-w+5mJ3GuFL+NjVtJlvydShqE1eN3h3PbI7/5LAsYJP/2qtuMXjfL2LpHSRqo4b4eSF5K/DH1JXKUAHSB2UW50g==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "is-callable": "^1.2.7",
+                "is-date-object": "^1.0.5",
+                "is-symbol": "^1.0.4"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/escape-string-regexp": {
+            "version": "4.0.0",
+            "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
+            "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=10"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
+        "node_modules/eslint": {
+            "version": "9.37.0",
+            "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.37.0.tgz",
+            "integrity": "sha512-XyLmROnACWqSxiGYArdef1fItQd47weqB7iwtfr9JHwRrqIXZdcFMvvEcL9xHCmL0SNsOvF0c42lWyM1U5dgig==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@eslint-community/eslint-utils": "^4.8.0",
+                "@eslint-community/regexpp": "^4.12.1",
+                "@eslint/config-array": "^0.21.0",
+                "@eslint/config-helpers": "^0.4.0",
+                "@eslint/core": "^0.16.0",
+                "@eslint/eslintrc": "^3.3.1",
+                "@eslint/js": "9.37.0",
+                "@eslint/plugin-kit": "^0.4.0",
+                "@humanfs/node": "^0.16.6",
+                "@humanwhocodes/module-importer": "^1.0.1",
+                "@humanwhocodes/retry": "^0.4.2",
+                "@types/estree": "^1.0.6",
+                "@types/json-schema": "^7.0.15",
+                "ajv": "^6.12.4",
+                "chalk": "^4.0.0",
+                "cross-spawn": "^7.0.6",
+                "debug": "^4.3.2",
+                "escape-string-regexp": "^4.0.0",
+                "eslint-scope": "^8.4.0",
+                "eslint-visitor-keys": "^4.2.1",
+                "espree": "^10.4.0",
+                "esquery": "^1.5.0",
+                "esutils": "^2.0.2",
+                "fast-deep-equal": "^3.1.3",
+                "file-entry-cache": "^8.0.0",
+                "find-up": "^5.0.0",
+                "glob-parent": "^6.0.2",
+                "ignore": "^5.2.0",
+                "imurmurhash": "^0.1.4",
+                "is-glob": "^4.0.0",
+                "json-stable-stringify-without-jsonify": "^1.0.1",
+                "lodash.merge": "^4.6.2",
+                "minimatch": "^3.1.2",
+                "natural-compare": "^1.4.0",
+                "optionator": "^0.9.3"
+            },
+            "bin": {
+                "eslint": "bin/eslint.js"
+            },
+            "engines": {
+                "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+            },
+            "funding": {
+                "url": "https://eslint.org/donate"
+            },
+            "peerDependencies": {
+                "jiti": "*"
+            },
+            "peerDependenciesMeta": {
+                "jiti": {
+                    "optional": true
+                }
+            }
+        },
+        "node_modules/eslint-compat-utils": {
+            "version": "0.6.5",
+            "resolved": "https://registry.npmjs.org/eslint-compat-utils/-/eslint-compat-utils-0.6.5.tgz",
+            "integrity": "sha512-vAUHYzue4YAa2hNACjB8HvUQj5yehAZgiClyFVVom9cP8z5NSFq3PwB/TtJslN2zAMgRX6FCFCjYBbQh71g5RQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "semver": "^7.5.4"
+            },
+            "engines": {
+                "node": ">=12"
+            },
+            "peerDependencies": {
+                "eslint": ">=6.0.0"
+            }
+        },
+        "node_modules/eslint-import-context": {
+            "version": "0.1.9",
+            "resolved": "https://registry.npmjs.org/eslint-import-context/-/eslint-import-context-0.1.9.tgz",
+            "integrity": "sha512-K9Hb+yRaGAGUbwjhFNHvSmmkZs9+zbuoe3kFQ4V1wYjrepUFYM2dZAfNtjbbj3qsPfUfsA68Bx/ICWQMi+C8Eg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "get-tsconfig": "^4.10.1",
+                "stable-hash-x": "^0.2.0"
+            },
+            "engines": {
+                "node": "^12.20.0 || ^14.18.0 || >=16.0.0"
+            },
+            "funding": {
+                "url": "https://opencollective.com/eslint-import-context"
+            },
+            "peerDependencies": {
+                "unrs-resolver": "^1.0.0"
+            },
+            "peerDependenciesMeta": {
+                "unrs-resolver": {
+                    "optional": true
+                }
+            }
+        },
+        "node_modules/eslint-import-resolver-node": {
+            "version": "0.3.9",
+            "resolved": "https://registry.npmjs.org/eslint-import-resolver-node/-/eslint-import-resolver-node-0.3.9.tgz",
+            "integrity": "sha512-WFj2isz22JahUv+B788TlO3N6zL3nNJGU8CcZbPZvVEkBPaJdCV4vy5wyghty5ROFbCRnm132v8BScu5/1BQ8g==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "debug": "^3.2.7",
+                "is-core-module": "^2.13.0",
+                "resolve": "^1.22.4"
+            }
+        },
+        "node_modules/eslint-import-resolver-node/node_modules/debug": {
+            "version": "3.2.7",
+            "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz",
+            "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "ms": "^2.1.1"
+            }
+        },
+        "node_modules/eslint-import-resolver-typescript": {
+            "version": "4.4.4",
+            "resolved": "https://registry.npmjs.org/eslint-import-resolver-typescript/-/eslint-import-resolver-typescript-4.4.4.tgz",
+            "integrity": "sha512-1iM2zeBvrYmUNTj2vSC/90JTHDth+dfOfiNKkxApWRsTJYNrc8rOdxxIf5vazX+BiAXTeOT0UvWpGI/7qIWQOw==",
+            "dev": true,
+            "license": "ISC",
+            "dependencies": {
+                "debug": "^4.4.1",
+                "eslint-import-context": "^0.1.8",
+                "get-tsconfig": "^4.10.1",
+                "is-bun-module": "^2.0.0",
+                "stable-hash-x": "^0.2.0",
+                "tinyglobby": "^0.2.14",
+                "unrs-resolver": "^1.7.11"
+            },
+            "engines": {
+                "node": "^16.17.0 || >=18.6.0"
+            },
+            "funding": {
+                "url": "https://opencollective.com/eslint-import-resolver-typescript"
+            },
+            "peerDependencies": {
+                "eslint": "*",
+                "eslint-plugin-import": "*",
+                "eslint-plugin-import-x": "*"
+            },
+            "peerDependenciesMeta": {
+                "eslint-plugin-import": {
+                    "optional": true
+                },
+                "eslint-plugin-import-x": {
+                    "optional": true
+                }
+            }
+        },
+        "node_modules/eslint-module-utils": {
+            "version": "2.12.1",
+            "resolved": "https://registry.npmjs.org/eslint-module-utils/-/eslint-module-utils-2.12.1.tgz",
+            "integrity": "sha512-L8jSWTze7K2mTg0vos/RuLRS5soomksDPoJLXIslC7c8Wmut3bx7CPpJijDcBZtxQ5lrbUdM+s0OlNbz0DCDNw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "debug": "^3.2.7"
+            },
+            "engines": {
+                "node": ">=4"
+            },
+            "peerDependenciesMeta": {
+                "eslint": {
+                    "optional": true
+                }
+            }
+        },
+        "node_modules/eslint-module-utils/node_modules/debug": {
+            "version": "3.2.7",
+            "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz",
+            "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "ms": "^2.1.1"
+            }
+        },
+        "node_modules/eslint-plugin-import": {
+            "version": "2.32.0",
+            "resolved": "https://registry.npmjs.org/eslint-plugin-import/-/eslint-plugin-import-2.32.0.tgz",
+            "integrity": "sha512-whOE1HFo/qJDyX4SnXzP4N6zOWn79WhnCUY/iDR0mPfQZO8wcYE4JClzI2oZrhBnnMUCBCHZhO6VQyoBU95mZA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@rtsao/scc": "^1.1.0",
+                "array-includes": "^3.1.9",
+                "array.prototype.findlastindex": "^1.2.6",
+                "array.prototype.flat": "^1.3.3",
+                "array.prototype.flatmap": "^1.3.3",
+                "debug": "^3.2.7",
+                "doctrine": "^2.1.0",
+                "eslint-import-resolver-node": "^0.3.9",
+                "eslint-module-utils": "^2.12.1",
+                "hasown": "^2.0.2",
+                "is-core-module": "^2.16.1",
+                "is-glob": "^4.0.3",
+                "minimatch": "^3.1.2",
+                "object.fromentries": "^2.0.8",
+                "object.groupby": "^1.0.3",
+                "object.values": "^1.2.1",
+                "semver": "^6.3.1",
+                "string.prototype.trimend": "^1.0.9",
+                "tsconfig-paths": "^3.15.0"
+            },
+            "engines": {
+                "node": ">=4"
+            },
+            "peerDependencies": {
+                "eslint": "^2 || ^3 || ^4 || ^5 || ^6 || ^7.2.0 || ^8 || ^9"
+            }
+        },
+        "node_modules/eslint-plugin-import/node_modules/brace-expansion": {
+            "version": "1.1.12",
+            "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
+            "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "balanced-match": "^1.0.0",
+                "concat-map": "0.0.1"
+            }
+        },
+        "node_modules/eslint-plugin-import/node_modules/debug": {
+            "version": "3.2.7",
+            "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz",
+            "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "ms": "^2.1.1"
+            }
+        },
+        "node_modules/eslint-plugin-import/node_modules/doctrine": {
+            "version": "2.1.0",
+            "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-2.1.0.tgz",
+            "integrity": "sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==",
+            "dev": true,
+            "license": "Apache-2.0",
+            "dependencies": {
+                "esutils": "^2.0.2"
+            },
+            "engines": {
+                "node": ">=0.10.0"
+            }
+        },
+        "node_modules/eslint-plugin-import/node_modules/minimatch": {
+            "version": "3.1.2",
+            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+            "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+            "dev": true,
+            "license": "ISC",
+            "dependencies": {
+                "brace-expansion": "^1.1.7"
+            },
+            "engines": {
+                "node": "*"
+            }
+        },
+        "node_modules/eslint-plugin-import/node_modules/semver": {
+            "version": "6.3.1",
+            "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+            "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+            "dev": true,
+            "license": "ISC",
+            "bin": {
+                "semver": "bin/semver.js"
+            }
+        },
+        "node_modules/eslint-plugin-react": {
+            "version": "7.37.5",
+            "resolved": "https://registry.npmjs.org/eslint-plugin-react/-/eslint-plugin-react-7.37.5.tgz",
+            "integrity": "sha512-Qteup0SqU15kdocexFNAJMvCJEfa2xUKNV4CC1xsVMrIIqEy3SQ/rqyxCWNzfrd3/ldy6HMlD2e0JDVpDg2qIA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "array-includes": "^3.1.8",
+                "array.prototype.findlast": "^1.2.5",
+                "array.prototype.flatmap": "^1.3.3",
+                "array.prototype.tosorted": "^1.1.4",
+                "doctrine": "^2.1.0",
+                "es-iterator-helpers": "^1.2.1",
+                "estraverse": "^5.3.0",
+                "hasown": "^2.0.2",
+                "jsx-ast-utils": "^2.4.1 || ^3.0.0",
+                "minimatch": "^3.1.2",
+                "object.entries": "^1.1.9",
+                "object.fromentries": "^2.0.8",
+                "object.values": "^1.2.1",
+                "prop-types": "^15.8.1",
+                "resolve": "^2.0.0-next.5",
+                "semver": "^6.3.1",
+                "string.prototype.matchall": "^4.0.12",
+                "string.prototype.repeat": "^1.0.0"
+            },
+            "engines": {
+                "node": ">=4"
+            },
+            "peerDependencies": {
+                "eslint": "^3 || ^4 || ^5 || ^6 || ^7 || ^8 || ^9.7"
+            }
+        },
+        "node_modules/eslint-plugin-react-hooks": {
+            "version": "5.2.0",
+            "resolved": "https://registry.npmjs.org/eslint-plugin-react-hooks/-/eslint-plugin-react-hooks-5.2.0.tgz",
+            "integrity": "sha512-+f15FfK64YQwZdJNELETdn5ibXEUQmW1DZL6KXhNnc2heoy/sg9VJJeT7n8TlMWouzWqSWavFkIhHyIbIAEapg==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=10"
+            },
+            "peerDependencies": {
+                "eslint": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0 || ^9.0.0"
+            }
+        },
+        "node_modules/eslint-plugin-react-refresh": {
+            "version": "0.4.20",
+            "resolved": "https://registry.npmjs.org/eslint-plugin-react-refresh/-/eslint-plugin-react-refresh-0.4.20.tgz",
+            "integrity": "sha512-XpbHQ2q5gUF8BGOX4dHe+71qoirYMhApEPZ7sfhF/dNnOF1UXnCMGZf79SFTBO7Bz5YEIT4TMieSlJBWhP9WBA==",
+            "dev": true,
+            "license": "MIT",
+            "peerDependencies": {
+                "eslint": ">=8.40"
+            }
+        },
+        "node_modules/eslint-plugin-react/node_modules/brace-expansion": {
+            "version": "1.1.12",
+            "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
+            "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "balanced-match": "^1.0.0",
+                "concat-map": "0.0.1"
+            }
+        },
+        "node_modules/eslint-plugin-react/node_modules/doctrine": {
+            "version": "2.1.0",
+            "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-2.1.0.tgz",
+            "integrity": "sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==",
+            "dev": true,
+            "license": "Apache-2.0",
+            "dependencies": {
+                "esutils": "^2.0.2"
+            },
+            "engines": {
+                "node": ">=0.10.0"
+            }
+        },
+        "node_modules/eslint-plugin-react/node_modules/minimatch": {
+            "version": "3.1.2",
+            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+            "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+            "dev": true,
+            "license": "ISC",
+            "dependencies": {
+                "brace-expansion": "^1.1.7"
+            },
+            "engines": {
+                "node": "*"
+            }
+        },
+        "node_modules/eslint-plugin-react/node_modules/resolve": {
+            "version": "2.0.0-next.5",
+            "resolved": "https://registry.npmjs.org/resolve/-/resolve-2.0.0-next.5.tgz",
+            "integrity": "sha512-U7WjGVG9sH8tvjW5SmGbQuui75FiyjAX72HX15DwBBwF9dNiQZRQAg9nnPhYy+TUnE0+VcrttuvNI8oSxZcocA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "is-core-module": "^2.13.0",
+                "path-parse": "^1.0.7",
+                "supports-preserve-symlinks-flag": "^1.0.0"
+            },
+            "bin": {
+                "resolve": "bin/resolve"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/eslint-plugin-react/node_modules/semver": {
+            "version": "6.3.1",
+            "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+            "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+            "dev": true,
+            "license": "ISC",
+            "bin": {
+                "semver": "bin/semver.js"
+            }
+        },
+        "node_modules/eslint-plugin-unused-imports": {
+            "version": "4.2.0",
+            "resolved": "https://registry.npmjs.org/eslint-plugin-unused-imports/-/eslint-plugin-unused-imports-4.2.0.tgz",
+            "integrity": "sha512-hLbJ2/wnjKq4kGA9AUaExVFIbNzyxYdVo49QZmKCnhk5pc9wcYRbfgLHvWJ8tnsdcseGhoUAddm9gn/lt+d74w==",
+            "dev": true,
+            "license": "MIT",
+            "peerDependencies": {
+                "@typescript-eslint/eslint-plugin": "^8.0.0-0 || ^7.0.0 || ^6.0.0 || ^5.0.0",
+                "eslint": "^9.0.0 || ^8.0.0"
+            },
+            "peerDependenciesMeta": {
+                "@typescript-eslint/eslint-plugin": {
+                    "optional": true
+                }
+            }
+        },
+        "node_modules/eslint-plugin-yml": {
+            "version": "1.18.0",
+            "resolved": "https://registry.npmjs.org/eslint-plugin-yml/-/eslint-plugin-yml-1.18.0.tgz",
+            "integrity": "sha512-9NtbhHRN2NJa/s3uHchO3qVVZw0vyOIvWlXWGaKCr/6l3Go62wsvJK5byiI6ZoYztDsow4GnS69BZD3GnqH3hA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "debug": "^4.3.2",
+                "escape-string-regexp": "4.0.0",
+                "eslint-compat-utils": "^0.6.0",
+                "natural-compare": "^1.4.0",
+                "yaml-eslint-parser": "^1.2.1"
+            },
+            "engines": {
+                "node": "^14.17.0 || >=16.0.0"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ota-meshi"
+            },
+            "peerDependencies": {
+                "eslint": ">=6.0.0"
+            }
+        },
+        "node_modules/eslint-scope": {
+            "version": "8.4.0",
+            "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.4.0.tgz",
+            "integrity": "sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==",
+            "dev": true,
+            "license": "BSD-2-Clause",
+            "dependencies": {
+                "esrecurse": "^4.3.0",
+                "estraverse": "^5.2.0"
+            },
+            "engines": {
+                "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+            },
+            "funding": {
+                "url": "https://opencollective.com/eslint"
+            }
+        },
+        "node_modules/eslint-visitor-keys": {
+            "version": "3.4.3",
+            "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz",
+            "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==",
+            "dev": true,
+            "license": "Apache-2.0",
+            "engines": {
+                "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+            },
+            "funding": {
+                "url": "https://opencollective.com/eslint"
+            }
+        },
+        "node_modules/eslint/node_modules/brace-expansion": {
+            "version": "1.1.12",
+            "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
+            "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "balanced-match": "^1.0.0",
+                "concat-map": "0.0.1"
+            }
+        },
+        "node_modules/eslint/node_modules/eslint-visitor-keys": {
+            "version": "4.2.1",
+            "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.1.tgz",
+            "integrity": "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==",
+            "dev": true,
+            "license": "Apache-2.0",
+            "engines": {
+                "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+            },
+            "funding": {
+                "url": "https://opencollective.com/eslint"
+            }
+        },
+        "node_modules/eslint/node_modules/ignore": {
+            "version": "5.3.2",
+            "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
+            "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">= 4"
+            }
+        },
+        "node_modules/eslint/node_modules/minimatch": {
+            "version": "3.1.2",
+            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+            "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+            "dev": true,
+            "license": "ISC",
+            "dependencies": {
+                "brace-expansion": "^1.1.7"
+            },
+            "engines": {
+                "node": "*"
+            }
+        },
+        "node_modules/espree": {
+            "version": "10.4.0",
+            "resolved": "https://registry.npmjs.org/espree/-/espree-10.4.0.tgz",
+            "integrity": "sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==",
+            "dev": true,
+            "license": "BSD-2-Clause",
+            "dependencies": {
+                "acorn": "^8.15.0",
+                "acorn-jsx": "^5.3.2",
+                "eslint-visitor-keys": "^4.2.1"
+            },
+            "engines": {
+                "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+            },
+            "funding": {
+                "url": "https://opencollective.com/eslint"
+            }
+        },
+        "node_modules/espree/node_modules/eslint-visitor-keys": {
+            "version": "4.2.1",
+            "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.1.tgz",
+            "integrity": "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==",
+            "dev": true,
+            "license": "Apache-2.0",
+            "engines": {
+                "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+            },
+            "funding": {
+                "url": "https://opencollective.com/eslint"
+            }
+        },
+        "node_modules/esquery": {
+            "version": "1.6.0",
+            "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.6.0.tgz",
+            "integrity": "sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==",
+            "dev": true,
+            "license": "BSD-3-Clause",
+            "dependencies": {
+                "estraverse": "^5.1.0"
+            },
+            "engines": {
+                "node": ">=0.10"
+            }
+        },
+        "node_modules/esrecurse": {
+            "version": "4.3.0",
+            "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz",
+            "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==",
+            "dev": true,
+            "license": "BSD-2-Clause",
+            "dependencies": {
+                "estraverse": "^5.2.0"
+            },
+            "engines": {
+                "node": ">=4.0"
+            }
+        },
+        "node_modules/estraverse": {
+            "version": "5.3.0",
+            "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
+            "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
+            "dev": true,
+            "license": "BSD-2-Clause",
+            "engines": {
+                "node": ">=4.0"
+            }
+        },
+        "node_modules/esutils": {
+            "version": "2.0.3",
+            "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
+            "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
+            "dev": true,
+            "license": "BSD-2-Clause",
+            "engines": {
+                "node": ">=0.10.0"
+            }
+        },
+        "node_modules/eventemitter3": {
+            "version": "5.0.1",
+            "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-5.0.1.tgz",
+            "integrity": "sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/fast-deep-equal": {
+            "version": "3.1.3",
+            "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+            "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/fast-glob": {
+            "version": "3.3.3",
+            "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.3.tgz",
+            "integrity": "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@nodelib/fs.stat": "^2.0.2",
+                "@nodelib/fs.walk": "^1.2.3",
+                "glob-parent": "^5.1.2",
+                "merge2": "^1.3.0",
+                "micromatch": "^4.0.8"
+            },
+            "engines": {
+                "node": ">=8.6.0"
+            }
+        },
+        "node_modules/fast-glob/node_modules/glob-parent": {
+            "version": "5.1.2",
+            "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+            "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+            "dev": true,
+            "license": "ISC",
+            "dependencies": {
+                "is-glob": "^4.0.1"
+            },
+            "engines": {
+                "node": ">= 6"
+            }
+        },
+        "node_modules/fast-json-stable-stringify": {
+            "version": "2.1.0",
+            "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
+            "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/fast-levenshtein": {
+            "version": "2.0.6",
+            "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
+            "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/fastq": {
+            "version": "1.19.1",
+            "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.19.1.tgz",
+            "integrity": "sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ==",
+            "dev": true,
+            "license": "ISC",
+            "dependencies": {
+                "reusify": "^1.0.4"
+            }
+        },
+        "node_modules/file-entry-cache": {
+            "version": "8.0.0",
+            "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-8.0.0.tgz",
+            "integrity": "sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "flat-cache": "^4.0.0"
+            },
+            "engines": {
+                "node": ">=16.0.0"
+            }
+        },
+        "node_modules/fill-range": {
+            "version": "7.1.1",
+            "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
+            "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "to-regex-range": "^5.0.1"
+            },
+            "engines": {
+                "node": ">=8"
+            }
+        },
+        "node_modules/find-up": {
+            "version": "5.0.0",
+            "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
+            "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "locate-path": "^6.0.0",
+                "path-exists": "^4.0.0"
+            },
+            "engines": {
+                "node": ">=10"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
+        "node_modules/flat-cache": {
+            "version": "4.0.1",
+            "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-4.0.1.tgz",
+            "integrity": "sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "flatted": "^3.2.9",
+                "keyv": "^4.5.4"
+            },
+            "engines": {
+                "node": ">=16"
+            }
+        },
+        "node_modules/flatted": {
+            "version": "3.3.3",
+            "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.3.3.tgz",
+            "integrity": "sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==",
+            "dev": true,
+            "license": "ISC"
+        },
+        "node_modules/for-each": {
+            "version": "0.3.5",
+            "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.5.tgz",
+            "integrity": "sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "is-callable": "^1.2.7"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/fsevents": {
+            "version": "2.3.2",
+            "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz",
+            "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==",
+            "dev": true,
+            "hasInstallScript": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "darwin"
+            ],
+            "engines": {
+                "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+            }
+        },
+        "node_modules/function-bind": {
+            "version": "1.1.2",
+            "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+            "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+            "dev": true,
+            "license": "MIT",
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/function.prototype.name": {
+            "version": "1.1.8",
+            "resolved": "https://registry.npmjs.org/function.prototype.name/-/function.prototype.name-1.1.8.tgz",
+            "integrity": "sha512-e5iwyodOHhbMr/yNrc7fDYG4qlbIvI5gajyzPnb5TCwyhjApznQh1BMFou9b30SevY43gCJKXycoCBjMbsuW0Q==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bind": "^1.0.8",
+                "call-bound": "^1.0.3",
+                "define-properties": "^1.2.1",
+                "functions-have-names": "^1.2.3",
+                "hasown": "^2.0.2",
+                "is-callable": "^1.2.7"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/functions-have-names": {
+            "version": "1.2.3",
+            "resolved": "https://registry.npmjs.org/functions-have-names/-/functions-have-names-1.2.3.tgz",
+            "integrity": "sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==",
+            "dev": true,
+            "license": "MIT",
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/get-east-asian-width": {
+            "version": "1.4.0",
+            "resolved": "https://registry.npmjs.org/get-east-asian-width/-/get-east-asian-width-1.4.0.tgz",
+            "integrity": "sha512-QZjmEOC+IT1uk6Rx0sX22V6uHWVwbdbxf1faPqJ1QhLdGgsRGCZoyaQBm/piRdJy/D2um6hM1UP7ZEeQ4EkP+Q==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=18"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
+        "node_modules/get-intrinsic": {
+            "version": "1.3.0",
+            "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+            "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bind-apply-helpers": "^1.0.2",
+                "es-define-property": "^1.0.1",
+                "es-errors": "^1.3.0",
+                "es-object-atoms": "^1.1.1",
+                "function-bind": "^1.1.2",
+                "get-proto": "^1.0.1",
+                "gopd": "^1.2.0",
+                "has-symbols": "^1.1.0",
+                "hasown": "^2.0.2",
+                "math-intrinsics": "^1.1.0"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/get-proto": {
+            "version": "1.0.1",
+            "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+            "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "dunder-proto": "^1.0.1",
+                "es-object-atoms": "^1.0.0"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            }
+        },
+        "node_modules/get-symbol-description": {
+            "version": "1.1.0",
+            "resolved": "https://registry.npmjs.org/get-symbol-description/-/get-symbol-description-1.1.0.tgz",
+            "integrity": "sha512-w9UMqWwJxHNOvoNzSJ2oPF5wvYcvP7jUvYzhp67yEhTi17ZDBBC1z9pTdGuzjD+EFIqLSYRweZjqfiPzQ06Ebg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bound": "^1.0.3",
+                "es-errors": "^1.3.0",
+                "get-intrinsic": "^1.2.6"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/get-tsconfig": {
+            "version": "4.10.1",
+            "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.10.1.tgz",
+            "integrity": "sha512-auHyJ4AgMz7vgS8Hp3N6HXSmlMdUyhSUrfBF16w153rxtLIEOE+HGqaBppczZvnHLqQJfiHotCYpNhl0lUROFQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "resolve-pkg-maps": "^1.0.0"
+            },
+            "funding": {
+                "url": "https://github.com/privatenumber/get-tsconfig?sponsor=1"
+            }
+        },
+        "node_modules/glob-parent": {
+            "version": "6.0.2",
+            "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
+            "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
+            "dev": true,
+            "license": "ISC",
+            "dependencies": {
+                "is-glob": "^4.0.3"
+            },
+            "engines": {
+                "node": ">=10.13.0"
+            }
+        },
+        "node_modules/globals": {
+            "version": "16.4.0",
+            "resolved": "https://registry.npmjs.org/globals/-/globals-16.4.0.tgz",
+            "integrity": "sha512-ob/2LcVVaVGCYN+r14cnwnoDPUufjiYgSqRhiFD0Q1iI4Odora5RE8Iv1D24hAz5oMophRGkGz+yuvQmmUMnMw==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=18"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
+        "node_modules/globalthis": {
+            "version": "1.0.4",
+            "resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.4.tgz",
+            "integrity": "sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "define-properties": "^1.2.1",
+                "gopd": "^1.0.1"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/gopd": {
+            "version": "1.2.0",
+            "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+            "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/graphemer": {
+            "version": "1.4.0",
+            "resolved": "https://registry.npmjs.org/graphemer/-/graphemer-1.4.0.tgz",
+            "integrity": "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/has-bigints": {
+            "version": "1.1.0",
+            "resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.1.0.tgz",
+            "integrity": "sha512-R3pbpkcIqv2Pm3dUwgjclDRVmWpTJW2DcMzcIhEXEx1oh/CEMObMm3KLmRJOdvhM7o4uQBnwr8pzRK2sJWIqfg==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/has-flag": {
+            "version": "4.0.0",
+            "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+            "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=8"
+            }
+        },
+        "node_modules/has-property-descriptors": {
+            "version": "1.0.2",
+            "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz",
+            "integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "es-define-property": "^1.0.0"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/has-proto": {
+            "version": "1.2.0",
+            "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.2.0.tgz",
+            "integrity": "sha512-KIL7eQPfHQRC8+XluaIw7BHUwwqL19bQn4hzNgdr+1wXoU0KKj6rufu47lhY7KbJR2C6T6+PfyN0Ea7wkSS+qQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "dunder-proto": "^1.0.0"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/has-symbols": {
+            "version": "1.1.0",
+            "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+            "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/has-tostringtag": {
+            "version": "1.0.2",
+            "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
+            "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "has-symbols": "^1.0.3"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/hasown": {
+            "version": "2.0.2",
+            "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
+            "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "function-bind": "^1.1.2"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            }
+        },
+        "node_modules/husky": {
+            "version": "9.1.7",
+            "resolved": "https://registry.npmjs.org/husky/-/husky-9.1.7.tgz",
+            "integrity": "sha512-5gs5ytaNjBrh5Ow3zrvdUUY+0VxIuWVL4i9irt6friV+BqdCfmV11CQTWMiBYWHbXhco+J1kHfTOUkePhCDvMA==",
+            "dev": true,
+            "license": "MIT",
+            "bin": {
+                "husky": "bin.js"
+            },
+            "engines": {
+                "node": ">=18"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/typicode"
+            }
+        },
+        "node_modules/ignore": {
+            "version": "7.0.5",
+            "resolved": "https://registry.npmjs.org/ignore/-/ignore-7.0.5.tgz",
+            "integrity": "sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">= 4"
+            }
+        },
+        "node_modules/import-fresh": {
+            "version": "3.3.1",
+            "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz",
+            "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "parent-module": "^1.0.0",
+                "resolve-from": "^4.0.0"
+            },
+            "engines": {
+                "node": ">=6"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
+        "node_modules/imurmurhash": {
+            "version": "0.1.4",
+            "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
+            "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=0.8.19"
+            }
+        },
+        "node_modules/internal-slot": {
+            "version": "1.1.0",
+            "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.1.0.tgz",
+            "integrity": "sha512-4gd7VpWNQNB4UKKCFFVcp1AVv+FMOgs9NKzjHKusc8jTMhd5eL1NqQqOpE0KzMds804/yHlglp3uxgluOqAPLw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "es-errors": "^1.3.0",
+                "hasown": "^2.0.2",
+                "side-channel": "^1.1.0"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            }
+        },
+        "node_modules/is-array-buffer": {
+            "version": "3.0.5",
+            "resolved": "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.5.tgz",
+            "integrity": "sha512-DDfANUiiG2wC1qawP66qlTugJeL5HyzMpfr8lLK+jMQirGzNod0B12cFB/9q838Ru27sBwfw78/rdoU7RERz6A==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bind": "^1.0.8",
+                "call-bound": "^1.0.3",
+                "get-intrinsic": "^1.2.6"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/is-async-function": {
+            "version": "2.1.1",
+            "resolved": "https://registry.npmjs.org/is-async-function/-/is-async-function-2.1.1.tgz",
+            "integrity": "sha512-9dgM/cZBnNvjzaMYHVoxxfPj2QXt22Ev7SuuPrs+xav0ukGB0S6d4ydZdEiM48kLx5kDV+QBPrpVnFyefL8kkQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "async-function": "^1.0.0",
+                "call-bound": "^1.0.3",
+                "get-proto": "^1.0.1",
+                "has-tostringtag": "^1.0.2",
+                "safe-regex-test": "^1.1.0"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/is-bigint": {
+            "version": "1.1.0",
+            "resolved": "https://registry.npmjs.org/is-bigint/-/is-bigint-1.1.0.tgz",
+            "integrity": "sha512-n4ZT37wG78iz03xPRKJrHTdZbe3IicyucEtdRsV5yglwc3GyUfbAfpSeD0FJ41NbUNSt5wbhqfp1fS+BgnvDFQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "has-bigints": "^1.0.2"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/is-boolean-object": {
+            "version": "1.2.2",
+            "resolved": "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.2.2.tgz",
+            "integrity": "sha512-wa56o2/ElJMYqjCjGkXri7it5FbebW5usLw/nPmCMs5DeZ7eziSYZhSmPRn0txqeW4LnAmQQU7FgqLpsEFKM4A==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bound": "^1.0.3",
+                "has-tostringtag": "^1.0.2"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/is-bun-module": {
+            "version": "2.0.0",
+            "resolved": "https://registry.npmjs.org/is-bun-module/-/is-bun-module-2.0.0.tgz",
+            "integrity": "sha512-gNCGbnnnnFAUGKeZ9PdbyeGYJqewpmc2aKHUEMO5nQPWU9lOmv7jcmQIv+qHD8fXW6W7qfuCwX4rY9LNRjXrkQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "semver": "^7.7.1"
+            }
+        },
+        "node_modules/is-callable": {
+            "version": "1.2.7",
+            "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz",
+            "integrity": "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/is-core-module": {
+            "version": "2.16.1",
+            "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.1.tgz",
+            "integrity": "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "hasown": "^2.0.2"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/is-data-view": {
+            "version": "1.0.2",
+            "resolved": "https://registry.npmjs.org/is-data-view/-/is-data-view-1.0.2.tgz",
+            "integrity": "sha512-RKtWF8pGmS87i2D6gqQu/l7EYRlVdfzemCJN/P3UOs//x1QE7mfhvzHIApBTRf7axvT6DMGwSwBXYCT0nfB9xw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bound": "^1.0.2",
+                "get-intrinsic": "^1.2.6",
+                "is-typed-array": "^1.1.13"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/is-date-object": {
+            "version": "1.1.0",
+            "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.1.0.tgz",
+            "integrity": "sha512-PwwhEakHVKTdRNVOw+/Gyh0+MzlCl4R6qKvkhuvLtPMggI1WAHt9sOwZxQLSGpUaDnrdyDsomoRgNnCfKNSXXg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bound": "^1.0.2",
+                "has-tostringtag": "^1.0.2"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/is-extglob": {
+            "version": "2.1.1",
+            "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+            "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=0.10.0"
+            }
+        },
+        "node_modules/is-finalizationregistry": {
+            "version": "1.1.1",
+            "resolved": "https://registry.npmjs.org/is-finalizationregistry/-/is-finalizationregistry-1.1.1.tgz",
+            "integrity": "sha512-1pC6N8qWJbWoPtEjgcL2xyhQOP491EQjeUo3qTKcmV8YSDDJrOepfG8pcC7h/QgnQHYSv0mJ3Z/ZWxmatVrysg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bound": "^1.0.3"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/is-fullwidth-code-point": {
+            "version": "5.1.0",
+            "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-5.1.0.tgz",
+            "integrity": "sha512-5XHYaSyiqADb4RnZ1Bdad6cPp8Toise4TzEjcOYDHZkTCbKgiUl7WTUCpNWHuxmDt91wnsZBc9xinNzopv3JMQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "get-east-asian-width": "^1.3.1"
+            },
+            "engines": {
+                "node": ">=18"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
+        "node_modules/is-generator-function": {
+            "version": "1.1.0",
+            "resolved": "https://registry.npmjs.org/is-generator-function/-/is-generator-function-1.1.0.tgz",
+            "integrity": "sha512-nPUB5km40q9e8UfN/Zc24eLlzdSf9OfKByBw9CIdw4H1giPMeA0OIJvbchsCu4npfI2QcMVBsGEBHKZ7wLTWmQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bound": "^1.0.3",
+                "get-proto": "^1.0.0",
+                "has-tostringtag": "^1.0.2",
+                "safe-regex-test": "^1.1.0"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/is-glob": {
+            "version": "4.0.3",
+            "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+            "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "is-extglob": "^2.1.1"
+            },
+            "engines": {
+                "node": ">=0.10.0"
+            }
+        },
+        "node_modules/is-map": {
+            "version": "2.0.3",
+            "resolved": "https://registry.npmjs.org/is-map/-/is-map-2.0.3.tgz",
+            "integrity": "sha512-1Qed0/Hr2m+YqxnM09CjA2d/i6YZNfF6R2oRAOj36eUdS6qIV/huPJNSEpKbupewFs+ZsJlxsjjPbc0/afW6Lw==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/is-negative-zero": {
+            "version": "2.0.3",
+            "resolved": "https://registry.npmjs.org/is-negative-zero/-/is-negative-zero-2.0.3.tgz",
+            "integrity": "sha512-5KoIu2Ngpyek75jXodFvnafB6DJgr3u8uuK0LEZJjrU19DrMD3EVERaR8sjz8CCGgpZvxPl9SuE1GMVPFHx1mw==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/is-number": {
+            "version": "7.0.0",
+            "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+            "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=0.12.0"
+            }
+        },
+        "node_modules/is-number-object": {
+            "version": "1.1.1",
+            "resolved": "https://registry.npmjs.org/is-number-object/-/is-number-object-1.1.1.tgz",
+            "integrity": "sha512-lZhclumE1G6VYD8VHe35wFaIif+CTy5SJIi5+3y4psDgWu4wPDoBhF8NxUOinEc7pHgiTsT6MaBb92rKhhD+Xw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bound": "^1.0.3",
+                "has-tostringtag": "^1.0.2"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/is-regex": {
+            "version": "1.2.1",
+            "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.2.1.tgz",
+            "integrity": "sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bound": "^1.0.2",
+                "gopd": "^1.2.0",
+                "has-tostringtag": "^1.0.2",
+                "hasown": "^2.0.2"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/is-set": {
+            "version": "2.0.3",
+            "resolved": "https://registry.npmjs.org/is-set/-/is-set-2.0.3.tgz",
+            "integrity": "sha512-iPAjerrse27/ygGLxw+EBR9agv9Y6uLeYVJMu+QNCoouJ1/1ri0mGrcWpfCqFZuzzx3WjtwxG098X+n4OuRkPg==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/is-shared-array-buffer": {
+            "version": "1.0.4",
+            "resolved": "https://registry.npmjs.org/is-shared-array-buffer/-/is-shared-array-buffer-1.0.4.tgz",
+            "integrity": "sha512-ISWac8drv4ZGfwKl5slpHG9OwPNty4jOWPRIhBpxOoD+hqITiwuipOQ2bNthAzwA3B4fIjO4Nln74N0S9byq8A==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bound": "^1.0.3"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/is-string": {
+            "version": "1.1.1",
+            "resolved": "https://registry.npmjs.org/is-string/-/is-string-1.1.1.tgz",
+            "integrity": "sha512-BtEeSsoaQjlSPBemMQIrY1MY0uM6vnS1g5fmufYOtnxLGUZM2178PKbhsk7Ffv58IX+ZtcvoGwccYsh0PglkAA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bound": "^1.0.3",
+                "has-tostringtag": "^1.0.2"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/is-symbol": {
+            "version": "1.1.1",
+            "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.1.1.tgz",
+            "integrity": "sha512-9gGx6GTtCQM73BgmHQXfDmLtfjjTUDSyoxTCbp5WtoixAhfgsDirWIcVQ/IHpvI5Vgd5i/J5F7B9cN/WlVbC/w==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bound": "^1.0.2",
+                "has-symbols": "^1.1.0",
+                "safe-regex-test": "^1.1.0"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/is-typed-array": {
+            "version": "1.1.15",
+            "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.15.tgz",
+            "integrity": "sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "which-typed-array": "^1.1.16"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/is-weakmap": {
+            "version": "2.0.2",
+            "resolved": "https://registry.npmjs.org/is-weakmap/-/is-weakmap-2.0.2.tgz",
+            "integrity": "sha512-K5pXYOm9wqY1RgjpL3YTkF39tni1XajUIkawTLUo9EZEVUFga5gSQJF8nNS7ZwJQ02y+1YCNYcMh+HIf1ZqE+w==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/is-weakref": {
+            "version": "1.1.1",
+            "resolved": "https://registry.npmjs.org/is-weakref/-/is-weakref-1.1.1.tgz",
+            "integrity": "sha512-6i9mGWSlqzNMEqpCp93KwRS1uUOodk2OJ6b+sq7ZPDSy2WuI5NFIxp/254TytR8ftefexkWn5xNiHUNpPOfSew==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bound": "^1.0.3"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/is-weakset": {
+            "version": "2.0.4",
+            "resolved": "https://registry.npmjs.org/is-weakset/-/is-weakset-2.0.4.tgz",
+            "integrity": "sha512-mfcwb6IzQyOKTs84CQMrOwW4gQcaTOAWJ0zzJCl2WSPDrWk/OzDaImWFH3djXhb24g4eudZfLRozAvPGw4d9hQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bound": "^1.0.3",
+                "get-intrinsic": "^1.2.6"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/isarray": {
+            "version": "2.0.5",
+            "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz",
+            "integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/isexe": {
+            "version": "2.0.0",
+            "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+            "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
+            "dev": true,
+            "license": "ISC"
+        },
+        "node_modules/iterator.prototype": {
+            "version": "1.1.5",
+            "resolved": "https://registry.npmjs.org/iterator.prototype/-/iterator.prototype-1.1.5.tgz",
+            "integrity": "sha512-H0dkQoCa3b2VEeKQBOxFph+JAbcrQdE7KC0UkqwpLmv2EC4P41QXP+rqo9wYodACiG5/WM5s9oDApTU8utwj9g==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "define-data-property": "^1.1.4",
+                "es-object-atoms": "^1.0.0",
+                "get-intrinsic": "^1.2.6",
+                "get-proto": "^1.0.0",
+                "has-symbols": "^1.1.0",
+                "set-function-name": "^2.0.2"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            }
+        },
+        "node_modules/js-tokens": {
+            "version": "4.0.0",
+            "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+            "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/js-yaml": {
+            "version": "4.1.0",
+            "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
+            "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "argparse": "^2.0.1"
+            },
+            "bin": {
+                "js-yaml": "bin/js-yaml.js"
+            }
+        },
+        "node_modules/json-buffer": {
+            "version": "3.0.1",
+            "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
+            "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/json-schema-traverse": {
+            "version": "0.4.1",
+            "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+            "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/json-stable-stringify-without-jsonify": {
+            "version": "1.0.1",
+            "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz",
+            "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/json5": {
+            "version": "1.0.2",
+            "resolved": "https://registry.npmjs.org/json5/-/json5-1.0.2.tgz",
+            "integrity": "sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "minimist": "^1.2.0"
+            },
+            "bin": {
+                "json5": "lib/cli.js"
+            }
+        },
+        "node_modules/jsx-ast-utils": {
+            "version": "3.3.5",
+            "resolved": "https://registry.npmjs.org/jsx-ast-utils/-/jsx-ast-utils-3.3.5.tgz",
+            "integrity": "sha512-ZZow9HBI5O6EPgSJLUb8n2NKgmVWTwCvHGwFuJlMjvLFqlGG6pjirPhtdsseaLZjSibD8eegzmYpUZwoIlj2cQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "array-includes": "^3.1.6",
+                "array.prototype.flat": "^1.3.1",
+                "object.assign": "^4.1.4",
+                "object.values": "^1.1.6"
+            },
+            "engines": {
+                "node": ">=4.0"
+            }
+        },
+        "node_modules/keyv": {
+            "version": "4.5.4",
+            "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
+            "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "json-buffer": "3.0.1"
+            }
+        },
+        "node_modules/levn": {
+            "version": "0.4.1",
+            "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz",
+            "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "prelude-ls": "^1.2.1",
+                "type-check": "~0.4.0"
+            },
+            "engines": {
+                "node": ">= 0.8.0"
+            }
+        },
+        "node_modules/lint-staged": {
+            "version": "16.2.4",
+            "resolved": "https://registry.npmjs.org/lint-staged/-/lint-staged-16.2.4.tgz",
+            "integrity": "sha512-Pkyr/wd90oAyXk98i/2KwfkIhoYQUMtss769FIT9hFM5ogYZwrk+GRE46yKXSg2ZGhcJ1p38Gf5gmI5Ohjg2yg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "commander": "^14.0.1",
+                "listr2": "^9.0.4",
+                "micromatch": "^4.0.8",
+                "nano-spawn": "^2.0.0",
+                "pidtree": "^0.6.0",
+                "string-argv": "^0.3.2",
+                "yaml": "^2.8.1"
+            },
+            "bin": {
+                "lint-staged": "bin/lint-staged.js"
+            },
+            "engines": {
+                "node": ">=20.17"
+            },
+            "funding": {
+                "url": "https://opencollective.com/lint-staged"
+            }
+        },
+        "node_modules/listr2": {
+            "version": "9.0.4",
+            "resolved": "https://registry.npmjs.org/listr2/-/listr2-9.0.4.tgz",
+            "integrity": "sha512-1wd/kpAdKRLwv7/3OKC8zZ5U8e/fajCfWMxacUvB79S5nLrYGPtUI/8chMQhn3LQjsRVErTb9i1ECAwW0ZIHnQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "cli-truncate": "^5.0.0",
+                "colorette": "^2.0.20",
+                "eventemitter3": "^5.0.1",
+                "log-update": "^6.1.0",
+                "rfdc": "^1.4.1",
+                "wrap-ansi": "^9.0.0"
+            },
+            "engines": {
+                "node": ">=20.0.0"
+            }
+        },
+        "node_modules/locate-path": {
+            "version": "6.0.0",
+            "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
+            "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "p-locate": "^5.0.0"
+            },
+            "engines": {
+                "node": ">=10"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
+        "node_modules/lodash.merge": {
+            "version": "4.6.2",
+            "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz",
+            "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/log-update": {
+            "version": "6.1.0",
+            "resolved": "https://registry.npmjs.org/log-update/-/log-update-6.1.0.tgz",
+            "integrity": "sha512-9ie8ItPR6tjY5uYJh8K/Zrv/RMZ5VOlOWvtZdEHYSTFKZfIBPQa9tOAEeAWhd+AnIneLJ22w5fjOYtoutpWq5w==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "ansi-escapes": "^7.0.0",
+                "cli-cursor": "^5.0.0",
+                "slice-ansi": "^7.1.0",
+                "strip-ansi": "^7.1.0",
+                "wrap-ansi": "^9.0.0"
+            },
+            "engines": {
+                "node": ">=18"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
+        "node_modules/loose-envify": {
+            "version": "1.4.0",
+            "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
+            "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "js-tokens": "^3.0.0 || ^4.0.0"
+            },
+            "bin": {
+                "loose-envify": "cli.js"
+            }
+        },
+        "node_modules/math-intrinsics": {
+            "version": "1.1.0",
+            "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+            "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">= 0.4"
+            }
+        },
+        "node_modules/merge2": {
+            "version": "1.4.1",
+            "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
+            "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">= 8"
+            }
+        },
+        "node_modules/micromatch": {
+            "version": "4.0.8",
+            "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
+            "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "braces": "^3.0.3",
+                "picomatch": "^2.3.1"
+            },
+            "engines": {
+                "node": ">=8.6"
+            }
+        },
+        "node_modules/mimic-function": {
+            "version": "5.0.1",
+            "resolved": "https://registry.npmjs.org/mimic-function/-/mimic-function-5.0.1.tgz",
+            "integrity": "sha512-VP79XUPxV2CigYP3jWwAUFSku2aKqBH7uTAapFWCBqutsbmDo96KY5o8uh6U+/YSIn5OxJnXp73beVkpqMIGhA==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=18"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
+        "node_modules/minimatch": {
+            "version": "9.0.5",
+            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
+            "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
+            "dev": true,
+            "license": "ISC",
+            "dependencies": {
+                "brace-expansion": "^2.0.1"
+            },
+            "engines": {
+                "node": ">=16 || 14 >=14.17"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/isaacs"
+            }
+        },
+        "node_modules/minimist": {
+            "version": "1.2.8",
+            "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
+            "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
+            "dev": true,
+            "license": "MIT",
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/ms": {
+            "version": "2.1.3",
+            "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+            "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/nano-spawn": {
+            "version": "2.0.0",
+            "resolved": "https://registry.npmjs.org/nano-spawn/-/nano-spawn-2.0.0.tgz",
+            "integrity": "sha512-tacvGzUY5o2D8CBh2rrwxyNojUsZNU2zjNTzKQrkgGJQTbGAfArVWXSKMBokBeeg6C7OLRGUEyoFlYbfeWQIqw==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=20.17"
+            },
+            "funding": {
+                "url": "https://github.com/sindresorhus/nano-spawn?sponsor=1"
+            }
+        },
+        "node_modules/napi-postinstall": {
+            "version": "0.3.3",
+            "resolved": "https://registry.npmjs.org/napi-postinstall/-/napi-postinstall-0.3.3.tgz",
+            "integrity": "sha512-uTp172LLXSxuSYHv/kou+f6KW3SMppU9ivthaVTXian9sOt3XM/zHYHpRZiLgQoxeWfYUnslNWQHF1+G71xcow==",
+            "dev": true,
+            "license": "MIT",
+            "bin": {
+                "napi-postinstall": "lib/cli.js"
+            },
+            "engines": {
+                "node": "^12.20.0 || ^14.18.0 || >=16.0.0"
+            },
+            "funding": {
+                "url": "https://opencollective.com/napi-postinstall"
+            }
+        },
+        "node_modules/natural-compare": {
+            "version": "1.4.0",
+            "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
+            "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/object-assign": {
+            "version": "4.1.1",
+            "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
+            "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=0.10.0"
+            }
+        },
+        "node_modules/object-inspect": {
+            "version": "1.13.4",
+            "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz",
+            "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/object-keys": {
+            "version": "1.1.1",
+            "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz",
+            "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">= 0.4"
+            }
+        },
+        "node_modules/object.assign": {
+            "version": "4.1.7",
+            "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.7.tgz",
+            "integrity": "sha512-nK28WOo+QIjBkDduTINE4JkF/UJJKyf2EJxvJKfblDpyg0Q+pkOHNTL0Qwy6NP6FhE/EnzV73BxxqcJaXY9anw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bind": "^1.0.8",
+                "call-bound": "^1.0.3",
+                "define-properties": "^1.2.1",
+                "es-object-atoms": "^1.0.0",
+                "has-symbols": "^1.1.0",
+                "object-keys": "^1.1.1"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/object.entries": {
+            "version": "1.1.9",
+            "resolved": "https://registry.npmjs.org/object.entries/-/object.entries-1.1.9.tgz",
+            "integrity": "sha512-8u/hfXFRBD1O0hPUjioLhoWFHRmt6tKA4/vZPyckBr18l1KE9uHrFaFaUi8MDRTpi4uak2goyPTSNJLXX2k2Hw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bind": "^1.0.8",
+                "call-bound": "^1.0.4",
+                "define-properties": "^1.2.1",
+                "es-object-atoms": "^1.1.1"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            }
+        },
+        "node_modules/object.fromentries": {
+            "version": "2.0.8",
+            "resolved": "https://registry.npmjs.org/object.fromentries/-/object.fromentries-2.0.8.tgz",
+            "integrity": "sha512-k6E21FzySsSK5a21KRADBd/NGneRegFO5pLHfdQLpRDETUNJueLXs3WCzyQ3tFRDYgbq3KHGXfTbi2bs8WQ6rQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bind": "^1.0.7",
+                "define-properties": "^1.2.1",
+                "es-abstract": "^1.23.2",
+                "es-object-atoms": "^1.0.0"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/object.groupby": {
+            "version": "1.0.3",
+            "resolved": "https://registry.npmjs.org/object.groupby/-/object.groupby-1.0.3.tgz",
+            "integrity": "sha512-+Lhy3TQTuzXI5hevh8sBGqbmurHbbIjAi0Z4S63nthVLmLxfbj4T54a4CfZrXIrt9iP4mVAPYMo/v99taj3wjQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bind": "^1.0.7",
+                "define-properties": "^1.2.1",
+                "es-abstract": "^1.23.2"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            }
+        },
+        "node_modules/object.values": {
+            "version": "1.2.1",
+            "resolved": "https://registry.npmjs.org/object.values/-/object.values-1.2.1.tgz",
+            "integrity": "sha512-gXah6aZrcUxjWg2zR2MwouP2eHlCBzdV4pygudehaKXSGW4v2AsRQUK+lwwXhii6KFZcunEnmSUoYp5CXibxtA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bind": "^1.0.8",
+                "call-bound": "^1.0.3",
+                "define-properties": "^1.2.1",
+                "es-object-atoms": "^1.0.0"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/onetime": {
+            "version": "7.0.0",
+            "resolved": "https://registry.npmjs.org/onetime/-/onetime-7.0.0.tgz",
+            "integrity": "sha512-VXJjc87FScF88uafS3JllDgvAm+c/Slfz06lorj2uAY34rlUu0Nt+v8wreiImcrgAjjIHp1rXpTDlLOGw29WwQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "mimic-function": "^5.0.0"
+            },
+            "engines": {
+                "node": ">=18"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
+        "node_modules/optionator": {
+            "version": "0.9.4",
+            "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
+            "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "deep-is": "^0.1.3",
+                "fast-levenshtein": "^2.0.6",
+                "levn": "^0.4.1",
+                "prelude-ls": "^1.2.1",
+                "type-check": "^0.4.0",
+                "word-wrap": "^1.2.5"
+            },
+            "engines": {
+                "node": ">= 0.8.0"
+            }
+        },
+        "node_modules/own-keys": {
+            "version": "1.0.1",
+            "resolved": "https://registry.npmjs.org/own-keys/-/own-keys-1.0.1.tgz",
+            "integrity": "sha512-qFOyK5PjiWZd+QQIh+1jhdb9LpxTF0qs7Pm8o5QHYZ0M3vKqSqzsZaEB6oWlxZ+q2sJBMI/Ktgd2N5ZwQoRHfg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "get-intrinsic": "^1.2.6",
+                "object-keys": "^1.1.1",
+                "safe-push-apply": "^1.0.0"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/p-limit": {
+            "version": "3.1.0",
+            "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
+            "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "yocto-queue": "^0.1.0"
+            },
+            "engines": {
+                "node": ">=10"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
+        "node_modules/p-locate": {
+            "version": "5.0.0",
+            "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
+            "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "p-limit": "^3.0.2"
+            },
+            "engines": {
+                "node": ">=10"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
+        "node_modules/parent-module": {
+            "version": "1.0.1",
+            "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
+            "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "callsites": "^3.0.0"
+            },
+            "engines": {
+                "node": ">=6"
+            }
+        },
+        "node_modules/path-exists": {
+            "version": "4.0.0",
+            "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
+            "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=8"
+            }
+        },
+        "node_modules/path-key": {
+            "version": "3.1.1",
+            "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+            "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=8"
+            }
+        },
+        "node_modules/path-parse": {
+            "version": "1.0.7",
+            "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
+            "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/picomatch": {
+            "version": "2.3.1",
+            "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
+            "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=8.6"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/jonschlinkert"
+            }
+        },
+        "node_modules/pidtree": {
+            "version": "0.6.0",
+            "resolved": "https://registry.npmjs.org/pidtree/-/pidtree-0.6.0.tgz",
+            "integrity": "sha512-eG2dWTVw5bzqGRztnHExczNxt5VGsE6OwTeCG3fdUf9KBsZzO3R5OIIIzWR+iZA0NtZ+RDVdaoE2dK1cn6jH4g==",
+            "dev": true,
+            "license": "MIT",
+            "bin": {
+                "pidtree": "bin/pidtree.js"
+            },
+            "engines": {
+                "node": ">=0.10"
+            }
+        },
+        "node_modules/playwright": {
+            "version": "1.55.0",
+            "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.55.0.tgz",
+            "integrity": "sha512-sdCWStblvV1YU909Xqx0DhOjPZE4/5lJsIS84IfN9dAZfcl/CIZ5O8l3o0j7hPMjDvqoTF8ZUcc+i/GL5erstA==",
+            "dev": true,
+            "license": "Apache-2.0",
+            "dependencies": {
+                "playwright-core": "1.55.0"
+            },
+            "bin": {
+                "playwright": "cli.js"
+            },
+            "engines": {
+                "node": ">=18"
+            },
+            "optionalDependencies": {
+                "fsevents": "2.3.2"
+            }
+        },
+        "node_modules/playwright-core": {
+            "version": "1.55.0",
+            "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.55.0.tgz",
+            "integrity": "sha512-GvZs4vU3U5ro2nZpeiwyb0zuFaqb9sUiAJuyrWpcGouD8y9/HLgGbNRjIph7zU9D3hnPaisMl9zG9CgFi/biIg==",
+            "dev": true,
+            "license": "Apache-2.0",
+            "bin": {
+                "playwright-core": "cli.js"
+            },
+            "engines": {
+                "node": ">=18"
+            }
+        },
+        "node_modules/possible-typed-array-names": {
+            "version": "1.1.0",
+            "resolved": "https://registry.npmjs.org/possible-typed-array-names/-/possible-typed-array-names-1.1.0.tgz",
+            "integrity": "sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">= 0.4"
+            }
+        },
+        "node_modules/prelude-ls": {
+            "version": "1.2.1",
+            "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
+            "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">= 0.8.0"
+            }
+        },
+        "node_modules/prettier": {
+            "version": "3.6.2",
+            "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.6.2.tgz",
+            "integrity": "sha512-I7AIg5boAr5R0FFtJ6rCfD+LFsWHp81dolrFD8S79U9tb8Az2nGrJncnMSnys+bpQJfRUzqs9hnA81OAA3hCuQ==",
+            "dev": true,
+            "license": "MIT",
+            "bin": {
+                "prettier": "bin/prettier.cjs"
+            },
+            "engines": {
+                "node": ">=14"
+            },
+            "funding": {
+                "url": "https://github.com/prettier/prettier?sponsor=1"
+            }
+        },
+        "node_modules/prop-types": {
+            "version": "15.8.1",
+            "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz",
+            "integrity": "sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "loose-envify": "^1.4.0",
+                "object-assign": "^4.1.1",
+                "react-is": "^16.13.1"
+            }
+        },
+        "node_modules/punycode": {
+            "version": "2.3.1",
+            "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
+            "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=6"
+            }
+        },
+        "node_modules/queue-microtask": {
+            "version": "1.2.3",
+            "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
+            "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==",
+            "dev": true,
+            "funding": [
+                {
+                    "type": "github",
+                    "url": "https://github.com/sponsors/feross"
+                },
+                {
+                    "type": "patreon",
+                    "url": "https://www.patreon.com/feross"
+                },
+                {
+                    "type": "consulting",
+                    "url": "https://feross.org/support"
+                }
+            ],
+            "license": "MIT"
+        },
+        "node_modules/react-is": {
+            "version": "16.13.1",
+            "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz",
+            "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/reflect.getprototypeof": {
+            "version": "1.0.10",
+            "resolved": "https://registry.npmjs.org/reflect.getprototypeof/-/reflect.getprototypeof-1.0.10.tgz",
+            "integrity": "sha512-00o4I+DVrefhv+nX0ulyi3biSHCPDe+yLv5o/p6d/UVlirijB8E16FtfwSAi4g3tcqrQ4lRAqQSoFEZJehYEcw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bind": "^1.0.8",
+                "define-properties": "^1.2.1",
+                "es-abstract": "^1.23.9",
+                "es-errors": "^1.3.0",
+                "es-object-atoms": "^1.0.0",
+                "get-intrinsic": "^1.2.7",
+                "get-proto": "^1.0.1",
+                "which-builtin-type": "^1.2.1"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/regexp.prototype.flags": {
+            "version": "1.5.4",
+            "resolved": "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.5.4.tgz",
+            "integrity": "sha512-dYqgNSZbDwkaJ2ceRd9ojCGjBq+mOm9LmtXnAnEGyHhN/5R7iDW2TRw3h+o/jCFxus3P2LfWIIiwowAjANm7IA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bind": "^1.0.8",
+                "define-properties": "^1.2.1",
+                "es-errors": "^1.3.0",
+                "get-proto": "^1.0.1",
+                "gopd": "^1.2.0",
+                "set-function-name": "^2.0.2"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/resolve": {
+            "version": "1.22.10",
+            "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.10.tgz",
+            "integrity": "sha512-NPRy+/ncIMeDlTAsuqwKIiferiawhefFJtkNSW0qZJEqMEb+qBt/77B/jGeeek+F0uOeN05CDa6HXbbIgtVX4w==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "is-core-module": "^2.16.0",
+                "path-parse": "^1.0.7",
+                "supports-preserve-symlinks-flag": "^1.0.0"
+            },
+            "bin": {
+                "resolve": "bin/resolve"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/resolve-from": {
+            "version": "4.0.0",
+            "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
+            "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=4"
+            }
+        },
+        "node_modules/resolve-pkg-maps": {
+            "version": "1.0.0",
+            "resolved": "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz",
+            "integrity": "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==",
+            "dev": true,
+            "license": "MIT",
+            "funding": {
+                "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1"
+            }
+        },
+        "node_modules/restore-cursor": {
+            "version": "5.1.0",
+            "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-5.1.0.tgz",
+            "integrity": "sha512-oMA2dcrw6u0YfxJQXm342bFKX/E4sG9rbTzO9ptUcR/e8A33cHuvStiYOwH7fszkZlZ1z/ta9AAoPk2F4qIOHA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "onetime": "^7.0.0",
+                "signal-exit": "^4.1.0"
+            },
+            "engines": {
+                "node": ">=18"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
+        "node_modules/reusify": {
+            "version": "1.1.0",
+            "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz",
+            "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "iojs": ">=1.0.0",
+                "node": ">=0.10.0"
+            }
+        },
+        "node_modules/rfdc": {
+            "version": "1.4.1",
+            "resolved": "https://registry.npmjs.org/rfdc/-/rfdc-1.4.1.tgz",
+            "integrity": "sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/run-parallel": {
+            "version": "1.2.0",
+            "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz",
+            "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==",
+            "dev": true,
+            "funding": [
+                {
+                    "type": "github",
+                    "url": "https://github.com/sponsors/feross"
+                },
+                {
+                    "type": "patreon",
+                    "url": "https://www.patreon.com/feross"
+                },
+                {
+                    "type": "consulting",
+                    "url": "https://feross.org/support"
+                }
+            ],
+            "license": "MIT",
+            "dependencies": {
+                "queue-microtask": "^1.2.2"
+            }
+        },
+        "node_modules/safe-array-concat": {
+            "version": "1.1.3",
+            "resolved": "https://registry.npmjs.org/safe-array-concat/-/safe-array-concat-1.1.3.tgz",
+            "integrity": "sha512-AURm5f0jYEOydBj7VQlVvDrjeFgthDdEF5H1dP+6mNpoXOMo1quQqJ4wvJDyRZ9+pO3kGWoOdmV08cSv2aJV6Q==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bind": "^1.0.8",
+                "call-bound": "^1.0.2",
+                "get-intrinsic": "^1.2.6",
+                "has-symbols": "^1.1.0",
+                "isarray": "^2.0.5"
+            },
+            "engines": {
+                "node": ">=0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/safe-push-apply": {
+            "version": "1.0.0",
+            "resolved": "https://registry.npmjs.org/safe-push-apply/-/safe-push-apply-1.0.0.tgz",
+            "integrity": "sha512-iKE9w/Z7xCzUMIZqdBsp6pEQvwuEebH4vdpjcDWnyzaI6yl6O9FHvVpmGelvEHNsoY6wGblkxR6Zty/h00WiSA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "es-errors": "^1.3.0",
+                "isarray": "^2.0.5"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/safe-regex-test": {
+            "version": "1.1.0",
+            "resolved": "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.1.0.tgz",
+            "integrity": "sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bound": "^1.0.2",
+                "es-errors": "^1.3.0",
+                "is-regex": "^1.2.1"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/semver": {
+            "version": "7.7.2",
+            "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz",
+            "integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==",
+            "dev": true,
+            "license": "ISC",
+            "bin": {
+                "semver": "bin/semver.js"
+            },
+            "engines": {
+                "node": ">=10"
+            }
+        },
+        "node_modules/set-function-length": {
+            "version": "1.2.2",
+            "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz",
+            "integrity": "sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "define-data-property": "^1.1.4",
+                "es-errors": "^1.3.0",
+                "function-bind": "^1.1.2",
+                "get-intrinsic": "^1.2.4",
+                "gopd": "^1.0.1",
+                "has-property-descriptors": "^1.0.2"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            }
+        },
+        "node_modules/set-function-name": {
+            "version": "2.0.2",
+            "resolved": "https://registry.npmjs.org/set-function-name/-/set-function-name-2.0.2.tgz",
+            "integrity": "sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "define-data-property": "^1.1.4",
+                "es-errors": "^1.3.0",
+                "functions-have-names": "^1.2.3",
+                "has-property-descriptors": "^1.0.2"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            }
+        },
+        "node_modules/set-proto": {
+            "version": "1.0.0",
+            "resolved": "https://registry.npmjs.org/set-proto/-/set-proto-1.0.0.tgz",
+            "integrity": "sha512-RJRdvCo6IAnPdsvP/7m6bsQqNnn1FCBX5ZNtFL98MmFF/4xAIJTIg1YbHW5DC2W5SKZanrC6i4HsJqlajw/dZw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "dunder-proto": "^1.0.1",
+                "es-errors": "^1.3.0",
+                "es-object-atoms": "^1.0.0"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            }
+        },
+        "node_modules/shebang-command": {
+            "version": "2.0.0",
+            "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+            "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "shebang-regex": "^3.0.0"
+            },
+            "engines": {
+                "node": ">=8"
+            }
+        },
+        "node_modules/shebang-regex": {
+            "version": "3.0.0",
+            "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+            "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=8"
+            }
+        },
+        "node_modules/side-channel": {
+            "version": "1.1.0",
+            "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz",
+            "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "es-errors": "^1.3.0",
+                "object-inspect": "^1.13.3",
+                "side-channel-list": "^1.0.0",
+                "side-channel-map": "^1.0.1",
+                "side-channel-weakmap": "^1.0.2"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/side-channel-list": {
+            "version": "1.0.0",
+            "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz",
+            "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "es-errors": "^1.3.0",
+                "object-inspect": "^1.13.3"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/side-channel-map": {
+            "version": "1.0.1",
+            "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz",
+            "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bound": "^1.0.2",
+                "es-errors": "^1.3.0",
+                "get-intrinsic": "^1.2.5",
+                "object-inspect": "^1.13.3"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/side-channel-weakmap": {
+            "version": "1.0.2",
+            "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz",
+            "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bound": "^1.0.2",
+                "es-errors": "^1.3.0",
+                "get-intrinsic": "^1.2.5",
+                "object-inspect": "^1.13.3",
+                "side-channel-map": "^1.0.1"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/signal-exit": {
+            "version": "4.1.0",
+            "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",
+            "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==",
+            "dev": true,
+            "license": "ISC",
+            "engines": {
+                "node": ">=14"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/isaacs"
+            }
+        },
+        "node_modules/slice-ansi": {
+            "version": "7.1.2",
+            "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-7.1.2.tgz",
+            "integrity": "sha512-iOBWFgUX7caIZiuutICxVgX1SdxwAVFFKwt1EvMYYec/NWO5meOJ6K5uQxhrYBdQJne4KxiqZc+KptFOWFSI9w==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "ansi-styles": "^6.2.1",
+                "is-fullwidth-code-point": "^5.0.0"
+            },
+            "engines": {
+                "node": ">=18"
+            },
+            "funding": {
+                "url": "https://github.com/chalk/slice-ansi?sponsor=1"
+            }
+        },
+        "node_modules/slice-ansi/node_modules/ansi-styles": {
+            "version": "6.2.3",
+            "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.3.tgz",
+            "integrity": "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=12"
+            },
+            "funding": {
+                "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+            }
+        },
+        "node_modules/stable-hash-x": {
+            "version": "0.2.0",
+            "resolved": "https://registry.npmjs.org/stable-hash-x/-/stable-hash-x-0.2.0.tgz",
+            "integrity": "sha512-o3yWv49B/o4QZk5ZcsALc6t0+eCelPc44zZsLtCQnZPDwFpDYSWcDnrv2TtMmMbQ7uKo3J0HTURCqckw23czNQ==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=12.0.0"
+            }
+        },
+        "node_modules/stop-iteration-iterator": {
+            "version": "1.1.0",
+            "resolved": "https://registry.npmjs.org/stop-iteration-iterator/-/stop-iteration-iterator-1.1.0.tgz",
+            "integrity": "sha512-eLoXW/DHyl62zxY4SCaIgnRhuMr6ri4juEYARS8E6sCEqzKpOiE521Ucofdx+KnDZl5xmvGYaaKCk5FEOxJCoQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "es-errors": "^1.3.0",
+                "internal-slot": "^1.1.0"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            }
+        },
+        "node_modules/string-argv": {
+            "version": "0.3.2",
+            "resolved": "https://registry.npmjs.org/string-argv/-/string-argv-0.3.2.tgz",
+            "integrity": "sha512-aqD2Q0144Z+/RqG52NeHEkZauTAUWJO8c6yTftGJKO3Tja5tUgIfmIl6kExvhtxSDP7fXB6DvzkfMpCd/F3G+Q==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=0.6.19"
+            }
+        },
+        "node_modules/string-width": {
+            "version": "8.1.0",
+            "resolved": "https://registry.npmjs.org/string-width/-/string-width-8.1.0.tgz",
+            "integrity": "sha512-Kxl3KJGb/gxkaUMOjRsQ8IrXiGW75O4E3RPjFIINOVH8AMl2SQ/yWdTzWwF3FevIX9LcMAjJW+GRwAlAbTSXdg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "get-east-asian-width": "^1.3.0",
+                "strip-ansi": "^7.1.0"
+            },
+            "engines": {
+                "node": ">=20"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
+        "node_modules/string.prototype.matchall": {
+            "version": "4.0.12",
+            "resolved": "https://registry.npmjs.org/string.prototype.matchall/-/string.prototype.matchall-4.0.12.tgz",
+            "integrity": "sha512-6CC9uyBL+/48dYizRf7H7VAYCMCNTBeM78x/VTUe9bFEaxBepPJDa1Ow99LqI/1yF7kuy7Q3cQsYMrcjGUcskA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bind": "^1.0.8",
+                "call-bound": "^1.0.3",
+                "define-properties": "^1.2.1",
+                "es-abstract": "^1.23.6",
+                "es-errors": "^1.3.0",
+                "es-object-atoms": "^1.0.0",
+                "get-intrinsic": "^1.2.6",
+                "gopd": "^1.2.0",
+                "has-symbols": "^1.1.0",
+                "internal-slot": "^1.1.0",
+                "regexp.prototype.flags": "^1.5.3",
+                "set-function-name": "^2.0.2",
+                "side-channel": "^1.1.0"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/string.prototype.repeat": {
+            "version": "1.0.0",
+            "resolved": "https://registry.npmjs.org/string.prototype.repeat/-/string.prototype.repeat-1.0.0.tgz",
+            "integrity": "sha512-0u/TldDbKD8bFCQ/4f5+mNRrXwZ8hg2w7ZR8wa16e8z9XpePWl3eGEcUD0OXpEH/VJH/2G3gjUtR3ZOiBe2S/w==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "define-properties": "^1.1.3",
+                "es-abstract": "^1.17.5"
+            }
+        },
+        "node_modules/string.prototype.trim": {
+            "version": "1.2.10",
+            "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.10.tgz",
+            "integrity": "sha512-Rs66F0P/1kedk5lyYyH9uBzuiI/kNRmwJAR9quK6VOtIpZ2G+hMZd+HQbbv25MgCA6gEffoMZYxlTod4WcdrKA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bind": "^1.0.8",
+                "call-bound": "^1.0.2",
+                "define-data-property": "^1.1.4",
+                "define-properties": "^1.2.1",
+                "es-abstract": "^1.23.5",
+                "es-object-atoms": "^1.0.0",
+                "has-property-descriptors": "^1.0.2"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/string.prototype.trimend": {
+            "version": "1.0.9",
+            "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.9.tgz",
+            "integrity": "sha512-G7Ok5C6E/j4SGfyLCloXTrngQIQU3PWtXGst3yM7Bea9FRURf1S42ZHlZZtsNque2FN2PoUhfZXYLNWwEr4dLQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bind": "^1.0.8",
+                "call-bound": "^1.0.2",
+                "define-properties": "^1.2.1",
+                "es-object-atoms": "^1.0.0"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/string.prototype.trimstart": {
+            "version": "1.0.8",
+            "resolved": "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.8.tgz",
+            "integrity": "sha512-UXSH262CSZY1tfu3G3Secr6uGLCFVPMhIqHjlgCUtCCcgihYc/xKs9djMTMUOb2j1mVSeU8EU6NWc/iQKU6Gfg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bind": "^1.0.7",
+                "define-properties": "^1.2.1",
+                "es-object-atoms": "^1.0.0"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/strip-ansi": {
+            "version": "7.1.2",
+            "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.2.tgz",
+            "integrity": "sha512-gmBGslpoQJtgnMAvOVqGZpEz9dyoKTCzy2nfz/n8aIFhN/jCE/rCmcxabB6jOOHV+0WNnylOxaxBQPSvcWklhA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "ansi-regex": "^6.0.1"
+            },
+            "engines": {
+                "node": ">=12"
+            },
+            "funding": {
+                "url": "https://github.com/chalk/strip-ansi?sponsor=1"
+            }
+        },
+        "node_modules/strip-bom": {
+            "version": "3.0.0",
+            "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz",
+            "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=4"
+            }
+        },
+        "node_modules/strip-json-comments": {
+            "version": "3.1.1",
+            "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
+            "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=8"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
+        "node_modules/supports-color": {
+            "version": "7.2.0",
+            "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+            "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "has-flag": "^4.0.0"
+            },
+            "engines": {
+                "node": ">=8"
+            }
+        },
+        "node_modules/supports-preserve-symlinks-flag": {
+            "version": "1.0.0",
+            "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz",
+            "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/tinyglobby": {
+            "version": "0.2.15",
+            "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
+            "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "fdir": "^6.5.0",
+                "picomatch": "^4.0.3"
+            },
+            "engines": {
+                "node": ">=12.0.0"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/SuperchupuDev"
+            }
+        },
+        "node_modules/tinyglobby/node_modules/fdir": {
+            "version": "6.5.0",
+            "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+            "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=12.0.0"
+            },
+            "peerDependencies": {
+                "picomatch": "^3 || ^4"
+            },
+            "peerDependenciesMeta": {
+                "picomatch": {
+                    "optional": true
+                }
+            }
+        },
+        "node_modules/tinyglobby/node_modules/picomatch": {
+            "version": "4.0.3",
+            "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+            "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=12"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/jonschlinkert"
+            }
+        },
+        "node_modules/to-regex-range": {
+            "version": "5.0.1",
+            "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+            "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "is-number": "^7.0.0"
+            },
+            "engines": {
+                "node": ">=8.0"
+            }
+        },
+        "node_modules/ts-api-utils": {
+            "version": "2.1.0",
+            "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-2.1.0.tgz",
+            "integrity": "sha512-CUgTZL1irw8u29bzrOD/nH85jqyc74D6SshFgujOIA7osm2Rz7dYH77agkx7H4FBNxDq7Cjf+IjaX/8zwFW+ZQ==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=18.12"
+            },
+            "peerDependencies": {
+                "typescript": ">=4.8.4"
+            }
+        },
+        "node_modules/tsconfig-paths": {
+            "version": "3.15.0",
+            "resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-3.15.0.tgz",
+            "integrity": "sha512-2Ac2RgzDe/cn48GvOe3M+o82pEFewD3UPbyoUHHdKasHwJKjds4fLXWf/Ux5kATBKN20oaFGu+jbElp1pos0mg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@types/json5": "^0.0.29",
+                "json5": "^1.0.2",
+                "minimist": "^1.2.6",
+                "strip-bom": "^3.0.0"
+            }
+        },
+        "node_modules/tslib": {
+            "version": "2.8.1",
+            "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+            "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+            "dev": true,
+            "license": "0BSD",
+            "optional": true
+        },
+        "node_modules/type-check": {
+            "version": "0.4.0",
+            "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",
+            "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "prelude-ls": "^1.2.1"
+            },
+            "engines": {
+                "node": ">= 0.8.0"
+            }
+        },
+        "node_modules/typed-array-buffer": {
+            "version": "1.0.3",
+            "resolved": "https://registry.npmjs.org/typed-array-buffer/-/typed-array-buffer-1.0.3.tgz",
+            "integrity": "sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bound": "^1.0.3",
+                "es-errors": "^1.3.0",
+                "is-typed-array": "^1.1.14"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            }
+        },
+        "node_modules/typed-array-byte-length": {
+            "version": "1.0.3",
+            "resolved": "https://registry.npmjs.org/typed-array-byte-length/-/typed-array-byte-length-1.0.3.tgz",
+            "integrity": "sha512-BaXgOuIxz8n8pIq3e7Atg/7s+DpiYrxn4vdot3w9KbnBhcRQq6o3xemQdIfynqSeXeDrF32x+WvfzmOjPiY9lg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bind": "^1.0.8",
+                "for-each": "^0.3.3",
+                "gopd": "^1.2.0",
+                "has-proto": "^1.2.0",
+                "is-typed-array": "^1.1.14"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/typed-array-byte-offset": {
+            "version": "1.0.4",
+            "resolved": "https://registry.npmjs.org/typed-array-byte-offset/-/typed-array-byte-offset-1.0.4.tgz",
+            "integrity": "sha512-bTlAFB/FBYMcuX81gbL4OcpH5PmlFHqlCCpAl8AlEzMz5k53oNDvN8p1PNOWLEmI2x4orp3raOFB51tv9X+MFQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "available-typed-arrays": "^1.0.7",
+                "call-bind": "^1.0.8",
+                "for-each": "^0.3.3",
+                "gopd": "^1.2.0",
+                "has-proto": "^1.2.0",
+                "is-typed-array": "^1.1.15",
+                "reflect.getprototypeof": "^1.0.9"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/typed-array-length": {
+            "version": "1.0.7",
+            "resolved": "https://registry.npmjs.org/typed-array-length/-/typed-array-length-1.0.7.tgz",
+            "integrity": "sha512-3KS2b+kL7fsuk/eJZ7EQdnEmQoaho/r6KUef7hxvltNA5DR8NAUM+8wJMbJyZ4G9/7i3v5zPBIMN5aybAh2/Jg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bind": "^1.0.7",
+                "for-each": "^0.3.3",
+                "gopd": "^1.0.1",
+                "is-typed-array": "^1.1.13",
+                "possible-typed-array-names": "^1.0.0",
+                "reflect.getprototypeof": "^1.0.6"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/typescript": {
+            "version": "5.9.3",
+            "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
+            "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+            "dev": true,
+            "license": "Apache-2.0",
+            "bin": {
+                "tsc": "bin/tsc",
+                "tsserver": "bin/tsserver"
+            },
+            "engines": {
+                "node": ">=14.17"
+            }
+        },
+        "node_modules/typescript-eslint": {
+            "version": "8.46.1",
+            "resolved": "https://registry.npmjs.org/typescript-eslint/-/typescript-eslint-8.46.1.tgz",
+            "integrity": "sha512-VHgijW803JafdSsDO8I761r3SHrgk4T00IdyQ+/UsthtgPRsBWQLqoSxOolxTpxRKi1kGXK0bSz4CoAc9ObqJA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@typescript-eslint/eslint-plugin": "8.46.1",
+                "@typescript-eslint/parser": "8.46.1",
+                "@typescript-eslint/typescript-estree": "8.46.1",
+                "@typescript-eslint/utils": "8.46.1"
+            },
+            "engines": {
+                "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+            },
+            "funding": {
+                "type": "opencollective",
+                "url": "https://opencollective.com/typescript-eslint"
+            },
+            "peerDependencies": {
+                "eslint": "^8.57.0 || ^9.0.0",
+                "typescript": ">=4.8.4 <6.0.0"
+            }
+        },
+        "node_modules/unbox-primitive": {
+            "version": "1.1.0",
+            "resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.1.0.tgz",
+            "integrity": "sha512-nWJ91DjeOkej/TA8pXQ3myruKpKEYgqvpw9lz4OPHj/NWFNluYrjbz9j01CJ8yKQd2g4jFoOkINCTW2I5LEEyw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bound": "^1.0.3",
+                "has-bigints": "^1.0.2",
+                "has-symbols": "^1.1.0",
+                "which-boxed-primitive": "^1.1.1"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/unrs-resolver": {
+            "version": "1.11.1",
+            "resolved": "https://registry.npmjs.org/unrs-resolver/-/unrs-resolver-1.11.1.tgz",
+            "integrity": "sha512-bSjt9pjaEBnNiGgc9rUiHGKv5l4/TGzDmYw3RhnkJGtLhbnnA/5qJj7x3dNDCRx/PJxu774LlH8lCOlB4hEfKg==",
+            "dev": true,
+            "hasInstallScript": true,
+            "license": "MIT",
+            "dependencies": {
+                "napi-postinstall": "^0.3.0"
+            },
+            "funding": {
+                "url": "https://opencollective.com/unrs-resolver"
+            },
+            "optionalDependencies": {
+                "@unrs/resolver-binding-android-arm-eabi": "1.11.1",
+                "@unrs/resolver-binding-android-arm64": "1.11.1",
+                "@unrs/resolver-binding-darwin-arm64": "1.11.1",
+                "@unrs/resolver-binding-darwin-x64": "1.11.1",
+                "@unrs/resolver-binding-freebsd-x64": "1.11.1",
+                "@unrs/resolver-binding-linux-arm-gnueabihf": "1.11.1",
+                "@unrs/resolver-binding-linux-arm-musleabihf": "1.11.1",
+                "@unrs/resolver-binding-linux-arm64-gnu": "1.11.1",
+                "@unrs/resolver-binding-linux-arm64-musl": "1.11.1",
+                "@unrs/resolver-binding-linux-ppc64-gnu": "1.11.1",
+                "@unrs/resolver-binding-linux-riscv64-gnu": "1.11.1",
+                "@unrs/resolver-binding-linux-riscv64-musl": "1.11.1",
+                "@unrs/resolver-binding-linux-s390x-gnu": "1.11.1",
+                "@unrs/resolver-binding-linux-x64-gnu": "1.11.1",
+                "@unrs/resolver-binding-linux-x64-musl": "1.11.1",
+                "@unrs/resolver-binding-wasm32-wasi": "1.11.1",
+                "@unrs/resolver-binding-win32-arm64-msvc": "1.11.1",
+                "@unrs/resolver-binding-win32-ia32-msvc": "1.11.1",
+                "@unrs/resolver-binding-win32-x64-msvc": "1.11.1"
+            }
+        },
+        "node_modules/uri-js": {
+            "version": "4.4.1",
+            "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
+            "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",
+            "dev": true,
+            "license": "BSD-2-Clause",
+            "dependencies": {
+                "punycode": "^2.1.0"
+            }
+        },
+        "node_modules/which": {
+            "version": "2.0.2",
+            "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+            "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+            "dev": true,
+            "license": "ISC",
+            "dependencies": {
+                "isexe": "^2.0.0"
+            },
+            "bin": {
+                "node-which": "bin/node-which"
+            },
+            "engines": {
+                "node": ">= 8"
+            }
+        },
+        "node_modules/which-boxed-primitive": {
+            "version": "1.1.1",
+            "resolved": "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.1.1.tgz",
+            "integrity": "sha512-TbX3mj8n0odCBFVlY8AxkqcHASw3L60jIuF8jFP78az3C2YhmGvqbHBpAjTRH2/xqYunrJ9g1jSyjCjpoWzIAA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "is-bigint": "^1.1.0",
+                "is-boolean-object": "^1.2.1",
+                "is-number-object": "^1.1.1",
+                "is-string": "^1.1.1",
+                "is-symbol": "^1.1.1"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/which-builtin-type": {
+            "version": "1.2.1",
+            "resolved": "https://registry.npmjs.org/which-builtin-type/-/which-builtin-type-1.2.1.tgz",
+            "integrity": "sha512-6iBczoX+kDQ7a3+YJBnh3T+KZRxM/iYNPXicqk66/Qfm1b93iu+yOImkg0zHbj5LNOcNv1TEADiZ0xa34B4q6Q==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bound": "^1.0.2",
+                "function.prototype.name": "^1.1.6",
+                "has-tostringtag": "^1.0.2",
+                "is-async-function": "^2.0.0",
+                "is-date-object": "^1.1.0",
+                "is-finalizationregistry": "^1.1.0",
+                "is-generator-function": "^1.0.10",
+                "is-regex": "^1.2.1",
+                "is-weakref": "^1.0.2",
+                "isarray": "^2.0.5",
+                "which-boxed-primitive": "^1.1.0",
+                "which-collection": "^1.0.2",
+                "which-typed-array": "^1.1.16"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/which-collection": {
+            "version": "1.0.2",
+            "resolved": "https://registry.npmjs.org/which-collection/-/which-collection-1.0.2.tgz",
+            "integrity": "sha512-K4jVyjnBdgvc86Y6BkaLZEN933SwYOuBFkdmBu9ZfkcAbdVbpITnDmjvZ/aQjRXQrv5EPkTnD1s39GiiqbngCw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "is-map": "^2.0.3",
+                "is-set": "^2.0.3",
+                "is-weakmap": "^2.0.2",
+                "is-weakset": "^2.0.3"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/which-typed-array": {
+            "version": "1.1.19",
+            "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.19.tgz",
+            "integrity": "sha512-rEvr90Bck4WZt9HHFC4DJMsjvu7x+r6bImz0/BrbWb7A2djJ8hnZMrWnHo9F8ssv0OMErasDhftrfROTyqSDrw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "available-typed-arrays": "^1.0.7",
+                "call-bind": "^1.0.8",
+                "call-bound": "^1.0.4",
+                "for-each": "^0.3.5",
+                "get-proto": "^1.0.1",
+                "gopd": "^1.2.0",
+                "has-tostringtag": "^1.0.2"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/word-wrap": {
+            "version": "1.2.5",
+            "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz",
+            "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=0.10.0"
+            }
+        },
+        "node_modules/wrap-ansi": {
+            "version": "9.0.2",
+            "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-9.0.2.tgz",
+            "integrity": "sha512-42AtmgqjV+X1VpdOfyTGOYRi0/zsoLqtXQckTmqTeybT+BDIbM/Guxo7x3pE2vtpr1ok6xRqM9OpBe+Jyoqyww==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "ansi-styles": "^6.2.1",
+                "string-width": "^7.0.0",
+                "strip-ansi": "^7.1.0"
+            },
+            "engines": {
+                "node": ">=18"
+            },
+            "funding": {
+                "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+            }
+        },
+        "node_modules/wrap-ansi/node_modules/ansi-styles": {
+            "version": "6.2.3",
+            "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.3.tgz",
+            "integrity": "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=12"
+            },
+            "funding": {
+                "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+            }
+        },
+        "node_modules/wrap-ansi/node_modules/string-width": {
+            "version": "7.2.0",
+            "resolved": "https://registry.npmjs.org/string-width/-/string-width-7.2.0.tgz",
+            "integrity": "sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "emoji-regex": "^10.3.0",
+                "get-east-asian-width": "^1.0.0",
+                "strip-ansi": "^7.1.0"
+            },
+            "engines": {
+                "node": ">=18"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
+        "node_modules/yaml": {
+            "version": "2.8.1",
+            "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.8.1.tgz",
+            "integrity": "sha512-lcYcMxX2PO9XMGvAJkJ3OsNMw+/7FKes7/hgerGUYWIoWu5j/+YQqcZr5JnPZWzOsEBgMbSbiSTn/dv/69Mkpw==",
+            "dev": true,
+            "license": "ISC",
+            "bin": {
+                "yaml": "bin.mjs"
+            },
+            "engines": {
+                "node": ">= 14.6"
+            }
+        },
+        "node_modules/yaml-eslint-parser": {
+            "version": "1.3.0",
+            "resolved": "https://registry.npmjs.org/yaml-eslint-parser/-/yaml-eslint-parser-1.3.0.tgz",
+            "integrity": "sha512-E/+VitOorXSLiAqtTd7Yqax0/pAS3xaYMP+AUUJGOK1OZG3rhcj9fcJOM5HJ2VrP1FrStVCWr1muTfQCdj4tAA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "eslint-visitor-keys": "^3.0.0",
+                "yaml": "^2.0.0"
+            },
+            "engines": {
+                "node": "^14.17.0 || >=16.0.0"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ota-meshi"
+            }
+        },
+        "node_modules/yocto-queue": {
+            "version": "0.1.0",
+            "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
+            "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=10"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        }
+    }
+}
diff --git a/ui-tests/package.json b/ui-tests/package.json
new file mode 100644
index 0000000000..adfd7b7389
--- /dev/null
+++ b/ui-tests/package.json
@@ -0,0 +1,49 @@
+{
+    "name": "ui-tests",
+    "version": "0.0.1",
+    "description": "",
+    "homepage": "https://github.com/Pometry/ui-tests",
+    "bugs": {
+        "url": "https://github.com/Pometry/ui-tests/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/Pometry/ui-tests.git"
+    },
+    "directories": {
+        "test": "tests"
+    },
+    "scripts": {
+        "format": "prettier --write .",
+        "format-check": "prettier --check .",
+        "eslint": "eslint . --ext ts,tsx --report-unused-disable-directives --max-warnings 0 --fix",
+        "eslint-check": "eslint . --ext ts,tsx --report-unused-disable-directives --max-warnings 0",
+        "install-playwright": "npx playwright install --with-deps",
+        "test": "npx playwright test",
+        "test-macos": "npx playwright test -c playwright.macos.config.ts",
+        "tsc": "tsc",
+        "prepare": "husky"
+    },
+    "devDependencies": {
+        "@eslint/compat": "^1.3.2",
+        "@eslint/js": "^9.33.0",
+        "@playwright/test": "^1.55.0",
+        "@typescript-eslint/eslint-plugin": "^8.39.1",
+        "@typescript-eslint/parser": "^8.39.1",
+        "dotenv": "^17.2.2",
+        "eslint": "^9.33.0",
+        "eslint-import-resolver-typescript": "^4.4.4",
+        "eslint-plugin-import": "^2.32.0",
+        "eslint-plugin-react": "^7.37.5",
+        "eslint-plugin-react-hooks": "^5.2.0",
+        "eslint-plugin-react-refresh": "^0.4.20",
+        "eslint-plugin-unused-imports": "^4.1.4",
+        "eslint-plugin-yml": "^1.18.0",
+        "globals": "^16.3.0",
+        "husky": "^9.1.7",
+        "lint-staged": "^16.2.4",
+        "prettier": "^3.6.2",
+        "typescript": "^5.9.3",
+        "typescript-eslint": "^8.39.1"
+    }
+}
diff --git a/ui-tests/playwright.config.ts b/ui-tests/playwright.config.ts
new file mode 100644
index 0000000000..2d63629d09
--- /dev/null
+++ b/ui-tests/playwright.config.ts
@@ -0,0 +1,77 @@
+import { defineConfig, devices } from '@playwright/test';
+import * as dotenv from 'dotenv';
+import * as path from 'path';
+
+/**
+ * Read environment variables from file.
+ * https://github.com/motdotla/dotenv
+ */
+dotenv.config({ path: path.resolve(__dirname, '.env'), quiet: true });
+dotenv.config({ path: path.resolve(__dirname, '..', '.env'), quiet: true });
+
+/**
+ * See https://playwright.dev/docs/test-configuration.
+ */
+export default defineConfig({
+    testDir: 'tests/e2e',
+    /* Run tests in files in parallel */
+    fullyParallel: true,
+    // /* Fail the build on CI if you accidentally left test.only in the source code. */
+    // forbidOnly: !!process.env.CI,
+    // /* Retry on CI only */
+    retries: 3,
+    /* Reporter to use. See https://playwright.dev/docs/test-reporters */
+    // We use blob on CI to enable sharding
+    reporter: 'html',
+    /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
+    use: {
+        /* Base URL to use in actions like `await page.goto('/')`. */
+        baseURL: process.env.UI_BASE_URL,
+
+        /* Collect trace when retrying the failed test. See https://playwright.dev/docs/trace-viewer */
+        trace: 'on-first-retry',
+
+        video: 'on-first-retry',
+    },
+
+    timeout: 30000,
+
+    /* Configure projects for major browsers */
+    projects: [
+        {
+            name: 'chromium',
+            use: { ...devices['Desktop Chrome'] },
+        },
+
+        {
+            name: 'firefox',
+            use: { ...devices['Desktop Firefox'] },
+        },
+
+        /* Test against mobile viewports. */
+        // {
+        //   name: 'Mobile Chrome',
+        //   use: { ...devices['Pixel 5'] },
+        // },
+        // {
+        //   name: 'Mobile Safari',
+        //   use: { ...devices['iPhone 12'] },
+        // },
+
+        /* Test against branded browsers. */
+        // {
+        //   name: 'Microsoft Edge',
+        //   use: { ...devices['Desktop Edge'], channel: 'msedge' },
+        // },
+        // {
+        //   name: 'Google Chrome',
+        //   use: { ...devices['Desktop Chrome'], channel: 'chrome' },
+        // },
+    ],
+
+    expect: {
+        toMatchSnapshot: {
+            maxDiffPixels: 2000,
+        },
+    },
+});
diff --git a/ui-tests/playwright.dockerfile b/ui-tests/playwright.dockerfile
new file mode 100644
index 0000000000..f6ed766711
--- /dev/null
+++ b/ui-tests/playwright.dockerfile
@@ -0,0 +1,15 @@
+FROM mcr.microsoft.com/playwright:v1.55.0
+WORKDIR /app
+
+COPY ./package.json .
+COPY ./package-lock.json .
+RUN npm install
+RUN apt-get update --fix-missing 
+RUN npx playwright install --with-deps
+
+COPY ./playwright.config.ts .
+COPY ./playwright.merge.config.ts .
+
+ENV PLAYWRIGHT_HTML_HOST=0.0.0.0
+
+CMD ["sh", "-c", "npx playwright test"]
\ No newline at end of file
diff --git a/ui-tests/playwright.macos.config.ts b/ui-tests/playwright.macos.config.ts
new file mode 100644
index 0000000000..0c72f7e021
--- /dev/null
+++ b/ui-tests/playwright.macos.config.ts
@@ -0,0 +1,72 @@
+import { defineConfig, devices } from '@playwright/test';
+import * as dotenv from 'dotenv';
+import * as path from 'path';
+
+/**
+ * Read environment variables from file.
+ * https://github.com/motdotla/dotenv
+ */
+dotenv.config({ path: path.resolve(__dirname, '.env'), quiet: true });
+dotenv.config({ path: path.resolve(__dirname, '..', '.env'), quiet: true });
+
+/**
+ * See https://playwright.dev/docs/test-configuration.
+ */
+export default defineConfig({
+    testDir: 'tests/e2e',
+    /* Run tests in files in parallel */
+    fullyParallel: true,
+    // /* Fail the build on CI if you accidentally left test.only in the source code. */
+    // forbidOnly: !!process.env.CI,
+    // /* Retry on CI only */
+    retries: 3,
+    /* Reporter to use. See https://playwright.dev/docs/test-reporters */
+    // We use blob on CI to enable sharding
+    reporter: 'html',
+    /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
+    use: {
+        /* Base URL to use in actions like `await page.goto('/')`. */
+        baseURL: process.env.UI_BASE_URL,
+
+        /* Collect trace when retrying the failed test. See https://playwright.dev/docs/trace-viewer */
+        trace: 'on-first-retry',
+
+        video: 'on-first-retry',
+    },
+
+    timeout: 30000,
+
+    /* Configure projects for major browsers */
+    projects: [
+        {
+            name: 'webkit',
+            use: { ...devices['Desktop Safari'] },
+        },
+
+        /* Test against mobile viewports. */
+        // {
+        //   name: 'Mobile Chrome',
+        //   use: { ...devices['Pixel 5'] },
+        // },
+        // {
+        //   name: 'Mobile Safari',
+        //   use: { ...devices['iPhone 12'] },
+        // },
+
+        /* Test against branded browsers. */
+        // {
+        //   name: 'Microsoft Edge',
+        //   use: { ...devices['Desktop Edge'], channel: 'msedge' },
+        // },
+        // {
+        //   name: 'Google Chrome',
+        //   use: { ...devices['Desktop Chrome'], channel: 'chrome' },
+        // },
+    ],
+
+    expect: {
+        toMatchSnapshot: {
+            maxDiffPixels: 2000,
+        },
+    },
+});
diff --git a/ui-tests/playwright.merge.config.ts b/ui-tests/playwright.merge.config.ts
new file mode 100644
index 0000000000..8cc44bbac1
--- /dev/null
+++ b/ui-tests/playwright.merge.config.ts
@@ -0,0 +1,4 @@
+export default {
+    testDir: 'tests/e2e',
+    reporter: [['html', { open: 'never' }]],
+};
diff --git a/ui-tests/test_server.py b/ui-tests/test_server.py
new file mode 100644
index 0000000000..d8c694c02f
--- /dev/null
+++ b/ui-tests/test_server.py
@@ -0,0 +1,187 @@
+import os
+import random
+from datetime import datetime, timedelta
+
+from raphtory import graphql, PersistentGraph, Graph
+
+
+## This is the test data for the UI tests so bare in mind they might fail if this file is changed
+
+
+def setup_graph(graph):
+    graph.add_node(1640995200000, "None")
+    graph.add_node(1648598400000, "Pedro", {"age": 28}, "Person")
+    graph.add_node(1656288000000, "Ben", {"age": 30}, "Person")
+    graph.add_node(1663977600000, "Hamza", {"age": 30}, "Person")
+
+    graph.add_edge(1671667200000, "Ben", "Hamza", {"where": "London"}, "meets")
+    graph.add_edge(1679356800000, "Ben", "Pedro", {"where": "Madrid"}, "meets")
+
+    graph.add_node(1687046400000, "Pometry", {}, "Company")
+    graph.add_edge(1687132800000, "Ben", "Pometry", {}, "founds")
+    graph.add_edge(1687132800000, "Hamza", "Pometry", {}, "founds")
+
+    graph.add_edge(1689734400000, "Hamza", "Pedro", {"where": "London"}, "meets")
+    graph.add_edge(1697424000000, "Hamza", "Pedro", {"where": "Madrid"}, "meets")
+
+    graph.add_edge(1705017600000, "Hamza", "Pedro", {"amount": 20}, "transfers")
+    graph.add_edge(1707609600000, "Pedro", "Hamza", {"amount": 40}, "transfers")
+    graph.add_edge(1710115200000, "Ben", "Hamza", {"amount": 40}, "transfers")
+
+    return graph
+
+
+def filler_graph(graph):
+    graph.add_node(0, "None")
+    graph.add_node(10, "Ben", {"age": 30}, "Person")
+    graph.add_node(20, "Hamza", {"age": 30}, "Person")
+
+    graph.add_edge(40, "Ben", "Hamza", {"where": "London"}, "meets")
+    graph.add_edge(50, "Ben", "Pedro", {"where": "Madrid"}, "meets")
+
+    graph.add_node(60, "Pometry", {}, "Company")
+    graph.add_edge(60, "Ben", "Pometry", {}, "founds")
+    graph.add_edge(60, "Hamza", "Pometry", {}, "founds")
+
+    return graph
+
+
+def second_filler_graph(graph):
+    graph.add_node(0, "None")
+    graph.add_node(10, "John", {"age": 40}, "Person")
+    graph.add_node(20, "Fred", {"age": 30}, "Person")
+    graph.add_node(25, "Judy", {"age": 30}, "Person")
+    graph.add_node(30, "Jasper", {"age": 20}, "Person")
+
+    graph.add_edge(
+        40,
+        "John",
+        "Fred",
+        {"where": "Amsterdam", "when": "2013-09-12", "reason": "coursemates"},
+        "meets",
+    )
+    graph.add_edge(
+        50,
+        "Fred",
+        "Judy",
+        {"where": "London", "when": "2020-04-23", "how_long": "2 days"},
+        "meets",
+    )
+
+    graph.add_node(
+        60, "Rabbit Inc", {"industry": "Agriculture", "founded": 2019}, "Company"
+    )
+
+    graph.add_edge(
+        61, "John", "Rabbit Inc", {"role": "Farmer", "start": "2019-01-01"}, "founds"
+    )
+    graph.add_edge(
+        62,
+        "Fred",
+        "Rabbit Inc",
+        {"role": "Tractor Driver", "start": "2019-01-01"},
+        "founds",
+    )
+
+    graph.add_edge(
+        70,
+        "Fred",
+        "Judy",
+        {"where": "Chipping Norton", "when": "2023-09-15", "topic": "hiring"},
+        "meets",
+    )
+    graph.add_edge(
+        80,
+        "John",
+        "Jasper",
+        {"where": "Hertfordshire", "when": "2024-03-10", "topic": "hiring"},
+        "meets",
+    )
+
+    graph.add_edge(
+        90,
+        "Judy",
+        "Jasper",
+        {
+            "where": "Chipping Norton",
+            "when": "2024-11-02",
+            "duration": "3 days",
+            "reason": "build a farm",
+        },
+        "collaborates",
+    )
+
+    graph.add_edge(
+        100, "Judy", "Rabbit Inc", {"role": "Advisor", "since": "2020-05-01"}, "advises"
+    )
+
+    graph.add_edge(
+        110,
+        "Fred",
+        "None",
+        {"reason": "reflects", "when": "2025-01-01"},
+        "thinks_about",
+    )
+
+    return graph
+
+
+def random_created_at():
+    today = datetime.now()
+    days_ago = random.randint(0, 365 * 10)
+    created = today - timedelta(days=days_ago)
+    return int(created.timestamp() * 1000)
+
+
+def setup_large_graph(graph):
+    graph.add_node(0, "center")
+    for i in range(0, 500):
+        name = str(random.randint(0, 10000000000))
+        created_date = random_created_at()
+        graph.add_node(
+            created_date,
+            name,
+            {
+                "location": str(random.randint(0, 10000000000)),
+                "age": random.randint(0, 100),
+            },
+            "User",
+        )
+        graph.add_edge(created_date, "center", name)
+
+    return graph
+
+
+def __main__():
+    os.system("rm -rf /tmp/vanilla-graphs/vanilla")
+    os.system("rm -rf /tmp/vanilla-graphs/new_folder")
+    os.system("mkdir -p /tmp/vanilla-graphs/vanilla")
+    os.system("mkdir -p /tmp/vanilla-graphs/new_folder")
+    graph = setup_graph(Graph())
+    graph.save_to_file("/tmp/vanilla-graphs/vanilla/event")
+
+    graph = setup_graph(PersistentGraph())
+    graph.delete_edge(90, "Ben", "Pedro", "meets")
+    graph.save_to_file("/tmp/vanilla-graphs/vanilla/persistent")
+
+    graph = setup_large_graph(Graph())
+    graph.save_to_file("/tmp/vanilla-graphs/vanilla/large")
+
+    graph = filler_graph(Graph())
+    graph.save_to_file("/tmp/vanilla-graphs/vanilla/filler")
+    graph = filler_graph(PersistentGraph())
+    graph.save_to_file("/tmp/vanilla-graphs/vanilla/persistent_filler")
+    graph.save_to_file("/tmp/vanilla-graphs/new_folder/persistent_filler")
+
+    graph = second_filler_graph(Graph())
+    graph.save_to_file("/tmp/vanilla-graphs/vanilla/second_filler")
+    graph = second_filler_graph(PersistentGraph())
+    graph.save_to_file("/tmp/vanilla-graphs/new_folder/persistent_second_filler")
+    graph.save_to_file("/tmp/vanilla-graphs/vanilla/persistent_second_filler")
+
+    server = graphql.GraphServer(work_dir="/tmp/vanilla-graphs")
+    server.run(port=1736)
+
+
+if __name__ == "__main__":
+    __main__()
diff --git a/ui-tests/tests/e2e/graph.spec.ts b/ui-tests/tests/e2e/graph.spec.ts
new file mode 100644
index 0000000000..8cfca7a39a
--- /dev/null
+++ b/ui-tests/tests/e2e/graph.spec.ts
@@ -0,0 +1,567 @@
+import { expect, Page, test } from '@playwright/test';
+import {
+    navigateToGraphPageBySearch,
+    navigateToSavedGraphBySavedGraphsTable,
+    selectLayout,
+    waitForLayoutToFinish,
+} from './utils';
+
+async function fitView(page: Page) {
+    await page
+        .getByRole('button', { name: 'Fit all nodes within visible region' })
+        .click();
+    await waitForLayoutToFinish(page);
+}
+
+test('Close right hand side panel button and open again', async ({ page }) => {
+    await page.goto('/graph?graphSource=vanilla%2Fevent&initialNodes=%5B%5D');
+
+    await page
+        .locator(
+            '.MuiButtonBase-root.MuiButton-root.MuiButton-text.MuiButton-textPrimary',
+        )
+        .nth(5)
+        .click();
+    await (await page.waitForSelector('text="Pedro"')).isHidden();
+    await page.getByText('Overview').isHidden();
+
+    await page
+        .locator(
+            '.MuiButtonBase-root.MuiButton-root.MuiButton-text.MuiButton-textPrimary',
+        )
+        .nth(5)
+        .click();
+
+    await page.getByText('Overview').isVisible();
+});
+
+test('Click save as button opens save as dialog', async ({ page }) => {
+    await page.goto('/graph?graphSource=vanilla%2Fevent&initialNodes=%5B%5D');
+    await page.locator('button:has-text("Save As")').click();
+    await page.getByRole('button', { name: 'Cancel' }).waitFor();
+    await expect(page.getByText('New Graph Name')).toBeVisible();
+
+    await page.getByRole('button', { name: 'Cancel' }).click();
+    await expect(page.getByText('New Graph Name')).toBeHidden();
+});
+
+test('Highlight founds then transfers', async ({ page }) => {
+    await page.goto('/graph?graphSource=vanilla%2Fevent&initialNodes=%5B%5D');
+    await expect(page.getByRole('progressbar')).toBeHidden();
+    await page.getByRole('button', { name: 'Relationships' }).waitFor();
+    await page
+        .getByRole('row', { name: 'transfers' })
+        .getByRole('button')
+        .click();
+    await expect(
+        page.locator('g', { hasText: /^Ben$/ }).locator('circle'),
+    ).toHaveCSS('fill', 'rgb(117, 135, 72)');
+    await expect(
+        page.locator('g', { hasText: /^Hamza$/ }).locator('circle'),
+    ).toHaveCSS('fill', 'rgb(117, 135, 72)');
+    await expect(
+        page.locator('g', { hasText: /^Pedro$/ }).locator('circle'),
+    ).toHaveCSS('fill', 'rgb(117, 135, 72)');
+    await page.getByRole('row', { name: 'founds' }).getByRole('button').click();
+    await expect(
+        page.locator('g', { hasText: /^Ben$/ }).locator('circle'),
+    ).toHaveCSS('fill', 'rgb(117, 135, 72)');
+    await expect(
+        page.locator('g', { hasText: /^Hamza$/ }).locator('circle'),
+    ).toHaveCSS('fill', 'rgb(117, 135, 72)');
+    await expect(
+        page.locator('g', { hasText: /^Pometry$/ }).locator('circle'),
+    ).toHaveCSS('fill', 'rgb(93, 212, 223)');
+});
+
+test('Test layouts', async ({ page }) => {
+    test.setTimeout(60000);
+    navigateToSavedGraphBySavedGraphsTable(page, 'vanilla', 'event');
+    // The extra timeout here helps to make the next line more consistent
+    await waitForLayoutToFinish(page, 3000);
+    await selectLayout(page, 'Concentric Layout');
+    expect(await page.screenshot()).toMatchSnapshot('concentric-layout.png');
+    await selectLayout(page, 'Force Based Layout');
+
+    expect(await page.screenshot()).toMatchSnapshot('force-based-layout.png');
+    await selectLayout(page, 'Hierarchical TD Layout');
+
+    expect(await page.screenshot()).toMatchSnapshot(
+        'hierarchical-td-layout.png',
+    );
+    await selectLayout(page, 'Hierarchical LR Layout');
+    expect(await page.screenshot()).toMatchSnapshot(
+        'hierarchical-lr-layout.png',
+    );
+    await selectLayout(page, 'Default Layout');
+    expect(await page.screenshot()).toMatchSnapshot('default-layout.png');
+});
+
+test('Zoom in, zoom out, fit view button', async ({ page }) => {
+    navigateToSavedGraphBySavedGraphsTable(page, 'vanilla', 'event');
+    await page.getByRole('button', { name: 'Zoom in' }).click();
+    await waitForLayoutToFinish(page);
+    expect(await page.screenshot()).toMatchSnapshot('zoomedin.png');
+    await page.getByRole('button', { name: 'Zoom out' }).click();
+    await waitForLayoutToFinish(page);
+    expect(await page.screenshot()).toMatchSnapshot('zoomedout.png');
+    await fitView(page);
+    expect(await page.screenshot()).toMatchSnapshot('fitview.png');
+});
+
+test('Click on Pometry node in graph', async ({ page }) => {
+    await navigateToGraphPageBySearch(page, {
+        type: 'node',
+        nodeName: 'Pometry',
+        nodeType: 'Company',
+    });
+    await page
+        .locator('canvas')
+        .nth(1)
+        .click({
+            position: {
+                x: 350,
+                y: 175,
+            },
+        });
+    await page.getByRole('tab', { name: 'Selected' }).click();
+    await expect(page.getByRole('heading', { name: 'Pometry' })).toBeVisible();
+    await expect(
+        page.getByText('No properties found', { exact: true }),
+    ).toBeVisible();
+});
+
+test('Click on Pedro node in graph', async ({ page }) => {
+    await navigateToGraphPageBySearch(page, {
+        type: 'node',
+        nodeName: 'Pedro',
+        nodeType: 'Person',
+    });
+    await page
+        .locator('canvas')
+        .nth(1)
+        .click({
+            position: {
+                x: 350,
+                y: 175,
+            },
+        });
+    await page.getByRole('tab', { name: 'Selected' }).click();
+    await expect(page.getByRole('heading', { name: 'Pedro' })).toBeVisible();
+    await expect(page.getByText('Age', { exact: true })).toBeVisible();
+});
+
+test('Click on Hamza node in graph', async ({ page }) => {
+    await navigateToGraphPageBySearch(page, {
+        type: 'node',
+        nodeName: 'Hamza',
+        nodeType: 'Person',
+    });
+    await waitForLayoutToFinish(page);
+    await page
+        .locator('canvas')
+        .nth(1)
+        .click({
+            position: {
+                x: 350,
+                y: 175,
+            },
+        });
+    await page.getByRole('tab', { name: 'Selected' }).click();
+    await expect(page.getByRole('heading', { name: 'Hamza' })).toBeVisible();
+    await expect(page.getByText('Age', { exact: true })).toBeVisible();
+});
+
+test('Click on Ben node in graph', async ({ page }) => {
+    await navigateToGraphPageBySearch(page, {
+        type: 'node',
+        nodeName: 'Ben',
+        nodeType: 'Person',
+    });
+    await page
+        .locator('canvas')
+        .nth(1)
+        .click({
+            position: {
+                x: 350,
+                y: 175,
+            },
+        });
+    await page.getByRole('tab', { name: 'Selected' }).click();
+    await expect(page.getByRole('heading', { name: 'Ben' })).toBeVisible();
+    await expect(page.getByText('Age', { exact: true })).toBeVisible();
+});
+
+test('Double click expand node and delete by floating actions button', async ({
+    page,
+}) => {
+    await navigateToGraphPageBySearch(page, {
+        type: 'node',
+        nodeName: 'Pedro',
+        nodeType: 'Person',
+    });
+    await page
+        .locator('canvas')
+        .nth(1)
+        .click({
+            position: {
+                x: 350,
+                y: 178,
+            },
+        });
+    await page.getByRole('tab', { name: 'Selected' }).click();
+    await expect(page.getByRole('heading', { name: 'Pedro' })).toBeVisible();
+    await page
+        .getByRole('button', {
+            name: 'Delete selected node from current graph',
+            exact: true,
+        })
+        .click();
+    await waitForLayoutToFinish(page);
+    expect(await page.screenshot()).toMatchSnapshot('deletednode.png', {
+        maxDiffPixels: 100,
+        maxDiffPixelRatio: 0.01,
+    });
+    await page.getByRole('tab', { name: 'Overview' }).click();
+    await page.getByRole('button', { name: 'Undo', exact: true }).click();
+
+    await waitForLayoutToFinish(page);
+    await page
+        .locator('canvas')
+        .nth(1)
+        .dblclick({
+            position: {
+                x: 350,
+                y: 175,
+            },
+        });
+
+    await page.waitForSelector('text=Pedro');
+    await expect(page.getByText('Ben')).toBeVisible();
+    await expect(page.getByText('Hamza')).toBeVisible();
+});
+
+test('Expand node by floating actions button', async ({ page }) => {
+    await navigateToGraphPageBySearch(page, {
+        type: 'node',
+        nodeName: 'Pedro',
+        nodeType: 'Person',
+    });
+
+    await page
+        .locator('canvas')
+        .nth(1)
+        .click({
+            position: {
+                x: 350,
+                y: 175,
+            },
+        });
+    await page
+        .getByRole('button', {
+            name: 'Explore',
+            exact: true,
+        })
+        .click();
+    await page
+        .getByRole('menuitem', {
+            name: 'Expand and show all nodes directly related to selected node',
+            exact: true,
+        })
+        .click();
+    await page.waitForSelector('text=Pedro');
+    await expect(page.getByText('Ben')).toBeVisible();
+    await expect(page.getByText('Hamza')).toBeVisible();
+    await expect(page.getByText('Pedro')).toBeVisible();
+});
+
+test('Expand two-hop by floating actions button', async ({ page }) => {
+    await navigateToGraphPageBySearch(page, {
+        type: 'node',
+        nodeName: 'Pedro',
+        nodeType: 'Person',
+    });
+
+    await page
+        .locator('canvas')
+        .nth(1)
+        .click({
+            position: {
+                x: 350,
+                y: 175,
+            },
+        });
+    await page
+        .getByRole('button', {
+            name: 'Explore',
+            exact: true,
+        })
+        .click();
+    await page
+        .getByRole('menuitem', {
+            name: 'Expand Two-Hop',
+            exact: true,
+        })
+        .click();
+    await page.waitForSelector('text=Pedro');
+    await expect(page.getByText('Ben')).toBeVisible();
+    await expect(page.getByText('Hamza')).toBeVisible();
+    await expect(page.getByText('Pedro')).toBeVisible();
+    await expect(page.getByText('Pometry')).toBeVisible();
+});
+
+test('Expand shared neighbours by floating actions button', async ({
+    page,
+}) => {
+    await navigateToGraphPageBySearch(page, {
+        type: 'edge',
+        src: 'Hamza',
+        dst: 'Pedro',
+        layers: ['meets'],
+    });
+
+    await page
+        .locator('canvas')
+        .nth(1)
+        .click({
+            position: {
+                x: 395,
+                y: 315,
+            },
+        });
+
+    await page
+        .locator('canvas')
+        .nth(1)
+        .click({
+            modifiers: ['Shift'],
+            position: {
+                x: 324,
+                y: 105,
+            },
+        });
+
+    await page
+        .getByRole('button', {
+            name: 'Explore',
+            exact: true,
+        })
+        .click();
+    await page
+        .getByRole('menuitem', {
+            name: 'Shared Neighbours',
+            exact: true,
+        })
+        .click();
+    await waitForLayoutToFinish(page);
+    await page.waitForSelector('text=Ben');
+    await expect(page.getByText('Ben')).toBeVisible();
+    await expect(page.getByText('Hamza')).toBeVisible();
+    await expect(page.getByText('Pedro')).toBeVisible();
+});
+
+test('Click edge to reveal right hand side panel details', async ({ page }) => {
+    await navigateToGraphPageBySearch(page, {
+        type: 'node',
+        nodeName: 'Pedro',
+        nodeType: 'Person',
+    });
+
+    await page
+        .locator('canvas')
+        .nth(1)
+        .dblclick({
+            position: {
+                x: 350,
+                y: 175,
+            },
+        });
+    await waitForLayoutToFinish(page, 2000);
+    await fitView(page);
+    await page
+        .locator('canvas')
+        .nth(1)
+        .click({
+            position: {
+                x: 350,
+                y: 164,
+            },
+        });
+    await page.waitForTimeout(100);
+    await page.getByRole('tab', { name: 'Selected' }).click();
+    await page.getByRole('button', { name: 'Edge Statistics' }).click();
+    await expect(page.getByText('Madrid')).toBeVisible();
+    await expect(page.getByText('Layer Names')).toBeVisible();
+    await expect(page.getByText('Earliest Time')).toBeVisible();
+    await expect(page.getByText('Latest Time')).toBeVisible();
+    await expect(page.getByText('meets, transfers')).toBeVisible();
+    await expect(page.getByText('Hamza -> Pedro')).toBeVisible();
+    await expect(page.getByText('Amount')).toBeVisible();
+    await page.getByRole('tab', { name: 'Pedro -> Hamza Log' }).click();
+    await expect(page.getByText('Pedro -> transfers -> Hamza')).toBeVisible();
+});
+
+test('Undo and redo in floating actions menu', async ({ page }) => {
+    await navigateToGraphPageBySearch(page, {
+        type: 'node',
+        nodeName: 'Pedro',
+        nodeType: 'Person',
+    });
+    await page
+        .locator('canvas')
+        .nth(1)
+        .dblclick({
+            position: {
+                x: 350,
+                y: 175,
+            },
+        });
+    await waitForLayoutToFinish(page);
+    await page.getByRole('button', { name: 'Undo', exact: true }).click();
+    await page.getByRole('button', { name: 'Redo', exact: true }).click();
+    await page.waitForSelector('text=Pedro');
+    await expect(page.getByText('Ben')).toBeVisible();
+    await expect(page.getByText('Hamza')).toBeVisible();
+    await expect(page.getByText('Pedro')).toBeVisible();
+});
+
+test('Expand node, fit view and select all similar nodes', async ({ page }) => {
+    await navigateToGraphPageBySearch(page, {
+        type: 'node',
+        nodeName: 'Pedro',
+        nodeType: 'Person',
+    });
+    const temporalView = await page
+        .locator('.css-gnkdhv-MuiPaper-root')
+        .boundingBox();
+    await page
+        .locator('canvas')
+        .nth(1)
+        .dblclick({
+            position: {
+                x: 350,
+                y: 175,
+            },
+        });
+    await waitForLayoutToFinish(page);
+    await page.waitForSelector('text="Pedro"');
+    await fitView(page);
+    await page
+        .locator('canvas')
+        .nth(1)
+        .click({
+            position: {
+                x: 430,
+                y: 104,
+            },
+        });
+    await page.getByRole('button', { name: 'Selection' }).click();
+    await page
+        .getByRole('menuitem', { name: 'Select all similar nodes' })
+        .click();
+    await waitForLayoutToFinish(page);
+    if (temporalView) {
+        expect(await page.screenshot({ clip: temporalView })).toMatchSnapshot(
+            'selectsimilarnodes.png',
+            {
+                maxDiffPixels: 20000,
+                maxDiffPixelRatio: 0.01,
+            },
+        );
+    } else {
+        throw new Error('Element not found or not visible');
+    }
+});
+
+test('Click and deselect by floating actions', async ({ page }) => {
+    await navigateToGraphPageBySearch(page, {
+        type: 'node',
+        nodeName: 'Pedro',
+        nodeType: 'Person',
+    });
+    await page
+        .locator('canvas')
+        .nth(1)
+        .click({
+            position: {
+                x: 350,
+                y: 175,
+            },
+        });
+    await page.getByRole('tab', { name: 'Selected' }).click();
+
+    await expect(page.getByText('Pedro').nth(0)).toBeVisible();
+    await page.getByRole('button', { name: 'Selection' }).click();
+    await page.getByRole('menuitem', { name: 'Deselect all nodes' }).click();
+    await waitForLayoutToFinish(page);
+    expect(await page.screenshot()).toMatchSnapshot('deselectnodes.png', {
+        maxDiffPixels: 20000,
+        maxDiffPixelRatio: 0.01,
+    });
+});
+
+test('Click backspace to delete nodes', async ({ page }) => {
+    await navigateToGraphPageBySearch(page, {
+        type: 'node',
+        nodeName: 'Pedro',
+        nodeType: 'Person',
+    });
+    await page
+        .locator('canvas')
+        .nth(1)
+        .dblclick({
+            position: {
+                x: 350,
+                y: 175,
+            },
+        });
+    await waitForLayoutToFinish(page);
+    await page.waitForSelector('text="Pedro"');
+    await fitView(page);
+    await page
+        .locator('canvas')
+        .nth(1)
+        .click({
+            position: {
+                x: 260,
+                y: 235,
+            },
+        });
+    await page.keyboard.press('Backspace');
+    await expect(page.getByText('Hamza')).toBeHidden();
+    await expect(page.getByText('Pedro')).toBeVisible();
+    await expect(page.getByText('Ben')).toBeVisible();
+});
+
+// skipping because we have a lot of random errors in the console, need to fix that first
+test.skip('catch any errors in the console', async ({ page }) => {
+    const consoleErrors: string[] = [];
+
+    page.on('console', (message) => {
+        if (message.type() === 'error') {
+            consoleErrors.push(message.text());
+        }
+    });
+
+    await page.goto('/graph?graphSource=vanilla%2Fevent&initialNodes=%5B%5D');
+
+    expect(consoleErrors, 'Console errors found').toEqual([]);
+});
+
+// skipping because it only works for one browser test, fails on other browser repeats (graph already exists after creating once in chromium)
+test.skip('save new graph with save as dialog', async ({ page }) => {
+    await page.goto('/graph?initialNodes=%5B"Pedro"%5D&baseGraph=event');
+
+    await page.locator('button:has-text("Save As")').click();
+    await expect(page.getByLabel('New Graph Name')).toBeVisible();
+
+    await page.getByLabel('New Graph Name').fill('Test Graph');
+    await page.getByRole('button', { name: 'Confirm' }).click();
+    await page.waitForLoadState('networkidle');
+
+    await page.waitForURL(
+        /\/graph\?graphSource=Test(\+|%20)Graph&initialNodes=%5B%5D/,
+    );
+
+    await expect(page.locator('input')).toHaveValue('Test Graph');
+});
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/concentric-layout-chromium-darwin.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/concentric-layout-chromium-darwin.png
new file mode 100644
index 0000000000..ba7aa4a067
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/concentric-layout-chromium-darwin.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/concentric-layout-chromium-linux.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/concentric-layout-chromium-linux.png
new file mode 100644
index 0000000000..80b76ed8ea
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/concentric-layout-chromium-linux.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/concentric-layout-firefox-darwin.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/concentric-layout-firefox-darwin.png
new file mode 100644
index 0000000000..bfd1c9866f
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/concentric-layout-firefox-darwin.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/concentric-layout-firefox-linux.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/concentric-layout-firefox-linux.png
new file mode 100644
index 0000000000..83981607e9
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/concentric-layout-firefox-linux.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/concentric-layout-webkit-darwin.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/concentric-layout-webkit-darwin.png
new file mode 100644
index 0000000000..121a98dabe
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/concentric-layout-webkit-darwin.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/concentric-layout-webkit-linux.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/concentric-layout-webkit-linux.png
new file mode 100644
index 0000000000..52da533529
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/concentric-layout-webkit-linux.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/default-layout-chromium-darwin.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/default-layout-chromium-darwin.png
new file mode 100644
index 0000000000..fbbf7b25c2
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/default-layout-chromium-darwin.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/default-layout-chromium-linux.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/default-layout-chromium-linux.png
new file mode 100644
index 0000000000..f0e2391e02
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/default-layout-chromium-linux.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/default-layout-firefox-darwin.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/default-layout-firefox-darwin.png
new file mode 100644
index 0000000000..8d634c3cf8
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/default-layout-firefox-darwin.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/default-layout-firefox-linux.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/default-layout-firefox-linux.png
new file mode 100644
index 0000000000..ee0d7aa7fd
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/default-layout-firefox-linux.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/default-layout-webkit-darwin.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/default-layout-webkit-darwin.png
new file mode 100644
index 0000000000..263d1e31a5
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/default-layout-webkit-darwin.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/default-layout-webkit-linux.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/default-layout-webkit-linux.png
new file mode 100644
index 0000000000..21fa29cbc7
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/default-layout-webkit-linux.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/deletednode-chromium-darwin.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/deletednode-chromium-darwin.png
new file mode 100644
index 0000000000..95e1c38bd8
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/deletednode-chromium-darwin.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/deletednode-chromium-linux.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/deletednode-chromium-linux.png
new file mode 100644
index 0000000000..dde5e57a5e
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/deletednode-chromium-linux.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/deletednode-firefox-darwin.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/deletednode-firefox-darwin.png
new file mode 100644
index 0000000000..808d7c0dac
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/deletednode-firefox-darwin.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/deletednode-firefox-linux.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/deletednode-firefox-linux.png
new file mode 100644
index 0000000000..4d9f8da8dc
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/deletednode-firefox-linux.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/deletednode-webkit-darwin.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/deletednode-webkit-darwin.png
new file mode 100644
index 0000000000..88bddad59f
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/deletednode-webkit-darwin.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/deletednode-webkit-linux.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/deletednode-webkit-linux.png
new file mode 100644
index 0000000000..3a6477fcde
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/deletednode-webkit-linux.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/deselectnodes-chromium-darwin.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/deselectnodes-chromium-darwin.png
new file mode 100644
index 0000000000..55b512be03
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/deselectnodes-chromium-darwin.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/deselectnodes-chromium-linux.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/deselectnodes-chromium-linux.png
new file mode 100644
index 0000000000..fc264f0221
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/deselectnodes-chromium-linux.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/deselectnodes-firefox-darwin.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/deselectnodes-firefox-darwin.png
new file mode 100644
index 0000000000..31dd0e4e14
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/deselectnodes-firefox-darwin.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/deselectnodes-firefox-linux.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/deselectnodes-firefox-linux.png
new file mode 100644
index 0000000000..79e7d36fd0
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/deselectnodes-firefox-linux.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/deselectnodes-webkit-darwin.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/deselectnodes-webkit-darwin.png
new file mode 100644
index 0000000000..a1fd89bda0
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/deselectnodes-webkit-darwin.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/deselectnodes-webkit-linux.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/deselectnodes-webkit-linux.png
new file mode 100644
index 0000000000..4309386c22
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/deselectnodes-webkit-linux.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/fitview-chromium-darwin.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/fitview-chromium-darwin.png
new file mode 100644
index 0000000000..4153ee745a
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/fitview-chromium-darwin.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/fitview-chromium-linux.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/fitview-chromium-linux.png
new file mode 100644
index 0000000000..29fe94c733
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/fitview-chromium-linux.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/fitview-firefox-darwin.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/fitview-firefox-darwin.png
new file mode 100644
index 0000000000..4bcfd244a6
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/fitview-firefox-darwin.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/fitview-firefox-linux.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/fitview-firefox-linux.png
new file mode 100644
index 0000000000..1db5615db4
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/fitview-firefox-linux.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/fitview-webkit-darwin.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/fitview-webkit-darwin.png
new file mode 100644
index 0000000000..706c74ec5d
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/fitview-webkit-darwin.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/fitview-webkit-linux.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/fitview-webkit-linux.png
new file mode 100644
index 0000000000..fe8c622c98
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/fitview-webkit-linux.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/force-based-layout-chromium-darwin.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/force-based-layout-chromium-darwin.png
new file mode 100644
index 0000000000..75a6e3b9c5
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/force-based-layout-chromium-darwin.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/force-based-layout-chromium-linux.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/force-based-layout-chromium-linux.png
new file mode 100644
index 0000000000..e7bba94f27
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/force-based-layout-chromium-linux.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/force-based-layout-firefox-darwin.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/force-based-layout-firefox-darwin.png
new file mode 100644
index 0000000000..08ec6348b5
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/force-based-layout-firefox-darwin.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/force-based-layout-firefox-linux.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/force-based-layout-firefox-linux.png
new file mode 100644
index 0000000000..0c22554e91
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/force-based-layout-firefox-linux.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/force-based-layout-webkit-darwin.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/force-based-layout-webkit-darwin.png
new file mode 100644
index 0000000000..ce5d9cd54c
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/force-based-layout-webkit-darwin.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/force-based-layout-webkit-linux.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/force-based-layout-webkit-linux.png
new file mode 100644
index 0000000000..651dc69512
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/force-based-layout-webkit-linux.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-lr-layout-chromium-darwin.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-lr-layout-chromium-darwin.png
new file mode 100644
index 0000000000..601dee1b8d
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-lr-layout-chromium-darwin.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-lr-layout-chromium-linux.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-lr-layout-chromium-linux.png
new file mode 100644
index 0000000000..ca471c50b8
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-lr-layout-chromium-linux.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-lr-layout-firefox-darwin.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-lr-layout-firefox-darwin.png
new file mode 100644
index 0000000000..9c893dccbe
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-lr-layout-firefox-darwin.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-lr-layout-firefox-linux.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-lr-layout-firefox-linux.png
new file mode 100644
index 0000000000..2e7b71be75
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-lr-layout-firefox-linux.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-lr-layout-webkit-darwin.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-lr-layout-webkit-darwin.png
new file mode 100644
index 0000000000..84e3d9d82f
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-lr-layout-webkit-darwin.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-lr-layout-webkit-linux.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-lr-layout-webkit-linux.png
new file mode 100644
index 0000000000..13da606d84
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-lr-layout-webkit-linux.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-td-layout-chromium-darwin.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-td-layout-chromium-darwin.png
new file mode 100644
index 0000000000..2eb77b114a
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-td-layout-chromium-darwin.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-td-layout-chromium-linux.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-td-layout-chromium-linux.png
new file mode 100644
index 0000000000..751897c5af
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-td-layout-chromium-linux.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-td-layout-firefox-darwin.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-td-layout-firefox-darwin.png
new file mode 100644
index 0000000000..bc4bebcedd
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-td-layout-firefox-darwin.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-td-layout-firefox-linux.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-td-layout-firefox-linux.png
new file mode 100644
index 0000000000..627572e3e5
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-td-layout-firefox-linux.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-td-layout-webkit-darwin.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-td-layout-webkit-darwin.png
new file mode 100644
index 0000000000..04573cb163
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-td-layout-webkit-darwin.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-td-layout-webkit-linux.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-td-layout-webkit-linux.png
new file mode 100644
index 0000000000..13da606d84
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/hierarchical-td-layout-webkit-linux.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/selectsimilarnodes-chromium-darwin.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/selectsimilarnodes-chromium-darwin.png
new file mode 100644
index 0000000000..2cb8367b7d
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/selectsimilarnodes-chromium-darwin.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/selectsimilarnodes-chromium-linux.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/selectsimilarnodes-chromium-linux.png
new file mode 100644
index 0000000000..8b1ca98eab
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/selectsimilarnodes-chromium-linux.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/selectsimilarnodes-firefox-darwin.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/selectsimilarnodes-firefox-darwin.png
new file mode 100644
index 0000000000..308845ddd9
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/selectsimilarnodes-firefox-darwin.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/selectsimilarnodes-firefox-linux.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/selectsimilarnodes-firefox-linux.png
new file mode 100644
index 0000000000..7a9e70582b
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/selectsimilarnodes-firefox-linux.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/selectsimilarnodes-webkit-darwin.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/selectsimilarnodes-webkit-darwin.png
new file mode 100644
index 0000000000..16f049167e
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/selectsimilarnodes-webkit-darwin.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/selectsimilarnodes-webkit-linux.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/selectsimilarnodes-webkit-linux.png
new file mode 100644
index 0000000000..4ed041e83c
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/selectsimilarnodes-webkit-linux.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedin-chromium-darwin.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedin-chromium-darwin.png
new file mode 100644
index 0000000000..b428a753b6
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedin-chromium-darwin.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedin-chromium-linux.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedin-chromium-linux.png
new file mode 100644
index 0000000000..650d399da2
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedin-chromium-linux.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedin-firefox-darwin.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedin-firefox-darwin.png
new file mode 100644
index 0000000000..17a78816bf
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedin-firefox-darwin.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedin-firefox-linux.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedin-firefox-linux.png
new file mode 100644
index 0000000000..106c94ad92
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedin-firefox-linux.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedin-webkit-darwin.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedin-webkit-darwin.png
new file mode 100644
index 0000000000..392c2ef250
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedin-webkit-darwin.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedin-webkit-linux.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedin-webkit-linux.png
new file mode 100644
index 0000000000..b30f5ffe33
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedin-webkit-linux.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedout-chromium-darwin.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedout-chromium-darwin.png
new file mode 100644
index 0000000000..131883abce
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedout-chromium-darwin.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedout-chromium-linux.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedout-chromium-linux.png
new file mode 100644
index 0000000000..14adc108f7
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedout-chromium-linux.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedout-firefox-darwin.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedout-firefox-darwin.png
new file mode 100644
index 0000000000..449af32d46
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedout-firefox-darwin.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedout-firefox-linux.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedout-firefox-linux.png
new file mode 100644
index 0000000000..ecc8afe3e4
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedout-firefox-linux.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedout-webkit-darwin.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedout-webkit-darwin.png
new file mode 100644
index 0000000000..b0874fc372
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedout-webkit-darwin.png differ
diff --git a/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedout-webkit-linux.png b/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedout-webkit-linux.png
new file mode 100644
index 0000000000..0e0fa0df89
Binary files /dev/null and b/ui-tests/tests/e2e/graph.spec.ts-snapshots/zoomedout-webkit-linux.png differ
diff --git a/ui-tests/tests/e2e/navbar.spec.ts b/ui-tests/tests/e2e/navbar.spec.ts
new file mode 100644
index 0000000000..899e4f2b94
--- /dev/null
+++ b/ui-tests/tests/e2e/navbar.spec.ts
@@ -0,0 +1,42 @@
+import { expect, test } from '@playwright/test';
+
+test('Page has title', async ({ page }) => {
+    await page.goto('/');
+
+    await expect(page).toHaveTitle('Pometry UI');
+});
+
+test('Search page link works', async ({ page }) => {
+    await page.goto('/');
+
+    await page.getByRole('button', { name: 'Search for a graph' }).click();
+    await expect(page).toHaveURL(/\/search$/);
+    await expect(page.getByText('Search for entities')).toBeVisible();
+});
+
+test('Saved graphs page link works', async ({ page }) => {
+    await page.goto('/');
+
+    await page.getByRole('button', { name: 'List of saved graphs' }).click();
+    await expect(page).toHaveURL(/\/saved-graphs$/);
+    await expect(
+        page.getByText(
+            'To see object details, please select an object in the graph canvas.',
+        ),
+    ).toBeVisible();
+});
+
+test('Home page link works', async ({ page }) => {
+    await page.goto('/');
+
+    await page.locator('img[alt="Pometry Logo"]').nth(0).click();
+    await expect(page).toHaveURL(/\/search$/);
+    await expect(page.getByText('Search for entities')).toBeVisible();
+});
+
+test('Playground link works', async ({ page }) => {
+    await page.goto('/');
+
+    await page.getByRole('button', { name: 'GraphQL Playground' }).click();
+    await expect(page).toHaveURL(/\/playground$/);
+});
diff --git a/ui-tests/tests/e2e/saved-graphs.spec.ts b/ui-tests/tests/e2e/saved-graphs.spec.ts
new file mode 100644
index 0000000000..ad67f5d684
--- /dev/null
+++ b/ui-tests/tests/e2e/saved-graphs.spec.ts
@@ -0,0 +1,183 @@
+import { expect, test } from '@playwright/test';
+
+test('Saved graphs table is visible', async ({ page }) => {
+    await page.goto('/saved-graphs');
+
+    await expect(
+        page.getByText(
+            'To see object details, please select an object in the graph canvas.',
+        ),
+    ).toBeVisible();
+
+    await page.getByRole('row', { name: /^vanilla$/ }).click();
+    await page.getByRole('table').locator('tbody tr').first().click();
+    await expect(page.getByText('Properties')).toBeVisible();
+    await expect(page.getByText('Preview')).toBeVisible();
+});
+
+test('Change rows per page to 5 in table and check pagination', async ({
+    page,
+}) => {
+    await page.goto('/saved-graphs');
+    await page.getByRole('row', { name: /^vanilla$/ }).click();
+    await page.getByRole('combobox').click();
+    await page.getByRole('option', { exact: true, name: '5' }).click();
+    const rows = page.locator('table tbody tr');
+    await expect(rows).toHaveCount(5);
+    await page.getByLabel('next page').click();
+    await expect(rows).toHaveCount(2);
+    await page.getByLabel('previous page').click();
+    await expect(rows).toHaveCount(5);
+    await page.getByRole('button', { name: '2' }).click();
+    await expect(rows).toHaveCount(2);
+    await page.getByRole('button', { name: '1' }).click();
+    await expect(rows).toHaveCount(5);
+});
+
+test('Row sorting on saved graphs table by columns', async ({ page }) => {
+    await page.goto('/saved-graphs');
+    const table = page.getByRole('table');
+    await page.getByRole('row', { name: /^vanilla$/ }).click();
+    //test Name
+    const nameHeader = table.getByRole('columnheader', { name: 'Name' });
+    await nameHeader.click();
+    const firstRow = table.locator('tbody tr').first();
+    const firstRowName = await firstRow.locator('td').nth(1).textContent();
+    await expect(firstRowName).toBe('second_filler');
+    await nameHeader.click();
+    const firstRowAfterSort = table.locator('tbody tr').first();
+    const firstRowNameAfterSort = await firstRowAfterSort
+        .locator('td')
+        .nth(1)
+        .textContent();
+    await expect(firstRowNameAfterSort).toBe('event');
+    await nameHeader.click();
+    const firstRowAfterSortAgain = table.locator('tbody tr').first();
+    const firstRowNameAfterSortAgain = await firstRowAfterSortAgain
+        .locator('td')
+        .nth(1)
+        .textContent();
+    await expect(firstRowNameAfterSortAgain).toBe('event');
+
+    //test Node Count
+    const nodeCountHeader = table.getByRole('columnheader', {
+        name: 'Node Count',
+    });
+    await nodeCountHeader.click();
+    const firstRowNodeCount = await firstRow.locator('td').nth(2).textContent();
+    await expect(firstRowNodeCount).toBe('501');
+    await nodeCountHeader.click();
+    const firstRowNodeCountAfterSort = await firstRowAfterSort
+        .locator('td')
+        .nth(2)
+        .textContent();
+    await expect(firstRowNodeCountAfterSort).toBe('5');
+
+    //test Edge Count
+    const edgeCountHeader = table.getByRole('columnheader', {
+        name: 'Edge Count',
+    });
+    await edgeCountHeader.click();
+    const firstRowEdgeCount = await firstRow.locator('td').nth(3).textContent();
+    await expect(firstRowEdgeCount).toBe('500');
+    await edgeCountHeader.click();
+    const firstRowEdgeCountAfterSort = await firstRowAfterSort
+        .locator('td')
+        .nth(3)
+        .textContent();
+    await expect(firstRowEdgeCountAfterSort).toBe('4');
+});
+
+test('Open graph by double clicking row', async ({ page }) => {
+    await page.goto('/saved-graphs');
+    const table = page.getByRole('table');
+    await expect(table).toBeVisible();
+    await page.getByRole('row', { name: /^vanilla$/ }).click();
+    await page.waitForLoadState('networkidle');
+    const firstRow = table.locator('tbody tr').first();
+    await firstRow.dblclick();
+    await expect(page).toHaveURL(
+        /\/graph\?graphSource=vanilla%2Fevent&initialNodes=%5B%5D/,
+    );
+});
+
+test('Open graph by clicking open button on rhs panel', async ({ page }) => {
+    await page.goto('/saved-graphs');
+    const table = page.getByRole('table');
+    await expect(table).toBeVisible();
+    await page.getByRole('row', { name: /^vanilla$/ }).click();
+    await table.locator('tbody tr').first().click();
+    await page.getByText('vanilla/event').isVisible();
+    await page.getByText('Namespace').isVisible();
+    await page
+        .getByLabel('Button group with a nested')
+        .getByRole('button', { name: 'Open' })
+        .click();
+
+    await page.waitForSelector('text=Overview');
+    await page.getByText('Overview').isVisible();
+    await expect(page).toHaveURL(
+        /\/graph\?graphSource=vanilla%2Fevent&initialNodes=%5B%5D/,
+    );
+});
+
+test('Open and close accordions on right hand side panel and open graph from minimap preview', async ({
+    page,
+}) => {
+    await page.goto('/saved-graphs');
+    const table = page.getByRole('table');
+    await expect(table).toBeVisible();
+    await page.getByRole('row', { name: /^vanilla$/ }).click();
+    const firstRow = table.locator('tbody tr').first();
+    await firstRow.click();
+    await page.getByRole('button', { name: 'Properties' }).click();
+    await expect(page.getByText('Namespace')).not.toBeVisible();
+    await page.getByRole('button', { name: 'Properties' }).click();
+    await expect(page.getByText('Namespace')).toBeVisible();
+    await page.getByRole('button', { name: 'Open' }).nth(1).click();
+    await expect(page).toHaveURL(
+        /\/graph\?graphSource=vanilla%2Fevent&initialNodes=%5B%5D/,
+    );
+});
+
+test('Search saved graphs table, clear search and hide search', async ({
+    page,
+}) => {
+    await page.goto('/saved-graphs');
+    const table = page.getByRole('table');
+    await expect(table).toBeVisible();
+    await page.getByRole('row', { name: /^vanilla$/ }).click();
+    await page.getByRole('button', { name: 'Show/Hide search' }).click();
+    const searchInput = page.getByPlaceholder('Search saved graphs');
+    await searchInput.fill('event');
+    const rows = table.locator('tbody tr');
+    await expect(rows).toHaveCount(1);
+    const firstRowName = await rows.first().locator('td').nth(1).textContent();
+    await expect(firstRowName).toBe('event');
+    await page.getByRole('button', { name: 'Clear search' }).click();
+    await page.getByRole('button', { name: 'Show/Hide search' }).click();
+    await expect(searchInput).toBeHidden();
+});
+
+test('Filter by Columns', async ({ page }) => {
+    await page.goto('/saved-graphs');
+    const table = page.getByRole('table');
+    await expect(table).toBeVisible();
+    await page.getByRole('row', { name: /^vanilla$/ }).click();
+    await page.waitForLoadState('networkidle');
+    await page.getByRole('button', { name: 'Show/Hide filters' }).click();
+    const filterNameInput = page.getByPlaceholder('Filter by Name');
+    await filterNameInput.fill('event');
+    const rows = table.locator('tbody tr');
+    await expect(rows).toHaveCount(1);
+    const firstRowName = await rows.first().locator('td').nth(1).textContent();
+    await expect(firstRowName).toBe('event');
+    await page.getByRole('button', { name: 'Clear filter' }).nth(1).click();
+    const filterNodeCountInput = page.getByPlaceholder('Filter by Node Count');
+    await filterNodeCountInput.fill('501');
+    await expect(rows).toHaveCount(1);
+    await page.getByRole('button', { name: 'Clear filter' }).nth(2).click();
+    const filterEdgeCountInput = page.getByPlaceholder('Filter by Edge Count');
+    await filterEdgeCountInput.fill('4');
+    await expect(rows).toHaveCount(2);
+});
diff --git a/ui-tests/tests/e2e/search-page.spec.ts b/ui-tests/tests/e2e/search-page.spec.ts
new file mode 100644
index 0000000000..1fdac3c402
--- /dev/null
+++ b/ui-tests/tests/e2e/search-page.spec.ts
@@ -0,0 +1,348 @@
+import { expect, Page, test } from '@playwright/test';
+import {
+    fillInCondition,
+    searchForEntity,
+    waitForLayoutToFinish,
+} from './utils';
+
+async function searchAndPinNodes(page: Page, amount: number) {
+    if (amount <= 0) {
+        return;
+    }
+
+    await searchForEntity(page, { type: 'node', nodeType: 'Person' });
+    const table = page.getByRole('table');
+    await expect(table).toBeVisible();
+    const rows = table.locator('tbody tr');
+    for (let i = 0; i < amount; i++) {
+        await rows.nth(i).click({ button: 'right' });
+        await page
+            .getByRole('menuitem', {
+                name: 'Add to Pinned',
+            })
+            .click();
+    }
+
+    const pinnedTab = page.getByRole('tab', { name: 'Pinned' });
+    await expect(pinnedTab).toBeVisible();
+    await pinnedTab.click();
+
+    await expect(
+        page.getByRole('button', { name: 'Unpin all items' }),
+    ).toBeVisible();
+    await expect(
+        page.getByRole('button', { name: 'Open all items in a new graph' }),
+    ).toBeVisible();
+    const pinnedRows = page.getByRole('table').locator('tbody tr');
+    await expect(pinnedRows).toHaveCount(Math.min(5, amount));
+}
+
+test('Search for a graph in the query builder, navigate direct connections table, check activity log and navigate to graph page', async ({
+    page,
+}) => {
+    await searchForEntity(page, { type: 'node', nodeType: 'Person' });
+    const table = page.getByRole('table');
+    await expect(table).toBeVisible();
+    const rows = table.locator('tbody tr');
+    await expect(rows).toHaveCount(3);
+    await rows.first().click();
+    const selectedTab = page.getByRole('tab', { name: 'Selected' });
+    await expect(selectedTab).toHaveAttribute('aria-selected', 'true');
+    await rows.nth(2).click();
+    await page.locator('button[aria-label="next page"]').click();
+    await expect(page.getByText('Page 2 of 2')).toBeVisible();
+    await expect(page.getByRole('table').nth(2)).toBeVisible();
+    await expect(
+        page.getByRole('table').nth(2).locator('tbody tr'),
+    ).toHaveCount(1);
+    const activityLogTab = page.getByRole('tab', { name: 'Activity Log' });
+    await expect(activityLogTab).toBeVisible();
+    await activityLogTab.click();
+    await expect(page.getByText('Event')).toBeVisible();
+    await expect(page.getByText('Timestamp')).toBeVisible();
+    await rows.first().dblclick();
+    await expect(page).toHaveURL(
+        /\/graph\?initialNodes=%5B%22Pedro%22%5D&baseGraph=vanilla%2Fevent/,
+    );
+});
+
+test('Clear search results in query builder', async ({ page }) => {
+    await searchForEntity(page, { type: 'node', nodeType: 'Person' });
+    await page
+        .getByRole('button', { name: 'Clear', exact: true })
+        .first()
+        .click();
+    await page
+        .getByRole('button', {
+            name: 'Select a graph',
+        })
+        .isVisible();
+    await expect(
+        page.getByRole('combobox', { name: 'Select type' }),
+    ).toHaveValue('');
+});
+
+test('Open node from right hand side panel open button', async ({ page }) => {
+    await searchForEntity(page, { type: 'node', nodeType: 'Person' });
+    const table = page.getByRole('table');
+    await expect(table).toBeVisible();
+    const rows = table.locator('tbody tr');
+    await rows.first().click();
+    const openNodeButton = page.getByRole('button', {
+        name: 'Open',
+        exact: true,
+    });
+    await expect(openNodeButton).toBeVisible();
+    await openNodeButton.click();
+    await expect(page).toHaveURL(
+        '/graph?baseGraph=vanilla%2Fevent&initialNodes=%5B%22Pedro%22%5D',
+    );
+});
+
+test('Pin and unpin a node with right hand side menu on search cards', async ({
+    page,
+}) => {
+    await searchAndPinNodes(page, 1);
+    const pinnedRows = page.getByRole('table').locator('tbody tr');
+    await pinnedRows.first().click({ button: 'right' });
+    await page
+        .getByRole('menuitem', {
+            name: 'Unpin',
+        })
+        .click();
+    await expect(pinnedRows).toHaveCount(0);
+});
+
+test('Unpin all nodes from pinned tab', async ({ page }) => {
+    await searchAndPinNodes(page, 2);
+    const unpinAllButton = page.getByRole('button', {
+        name: 'Unpin all items',
+        exact: true,
+    });
+    await expect(unpinAllButton).toBeVisible();
+    await unpinAllButton.click();
+    const pinnedRows = page.getByRole('table').locator('tbody tr');
+    await expect(pinnedRows).toHaveCount(0);
+});
+
+test('View information in right hand side panel and open in graph view button in right click menu', async ({
+    page,
+}) => {
+    await searchForEntity(page, { type: 'node', nodeType: 'Person' });
+    const table = page.getByRole('table');
+    await expect(table).toBeVisible();
+    const rows = table.locator('tbody tr');
+    await rows.first().click({ button: 'right' });
+    await page
+        .getByRole('menuitem', {
+            name: 'View information',
+        })
+        .click();
+    await page.getByRole('button', { name: 'Explorer' }).isVisible();
+    await page.getByRole('button', { name: 'Explorer' }).click();
+    await rows.first().click({ button: 'right' });
+    const openInGraphButton = page.getByRole('menuitem', {
+        name: 'Open in graph view',
+        exact: true,
+    });
+    await expect(openInGraphButton).toBeVisible();
+    await openInGraphButton.click();
+    await expect(page).toHaveURL(
+        '/graph?initialNodes=%5B%22Pedro%22%5D&baseGraph=vanilla%2Fevent',
+    );
+});
+
+test('Open all items to new graph button on pinned tab', async ({ page }) => {
+    await searchAndPinNodes(page, 1);
+    const attachAllButton = page.getByRole('button', {
+        name: 'Open all items in a new graph',
+        exact: true,
+    });
+    await expect(attachAllButton).toBeVisible();
+    await attachAllButton.click();
+    await expect(page).toHaveURL(
+        '/graph?initialNodes=%5B%22Pedro%22%5D&baseGraph=vanilla%2Fevent',
+    );
+});
+
+test('pin and unpin via right hand side menu button', async ({ page }) => {
+    await searchForEntity(page, { type: 'node', nodeType: 'Person' });
+    const table = page.getByRole('table');
+    await expect(table).toBeVisible();
+    const rows = table.locator('tbody tr');
+    await rows.first().click();
+    await page.getByRole('button', { name: 'select merge strategy' }).click();
+    await page
+        .getByRole('menuitem', { name: 'Pin Node' })
+        .locator('div')
+        .first()
+        .click();
+    await page.getByRole('tab', { name: 'Pinned' }).click();
+    await page.getByRole('button', { name: 'Pedro Age' }).click();
+    await page.getByRole('button', { name: 'select merge strategy' }).click();
+    await page.getByRole('menuitem', { name: 'Unpin Node' }).click();
+    await expect(page.getByText('No pinned nodes.')).toBeVisible();
+});
+
+test('Search for relationships in query builder', async ({ page }) => {
+    await searchForEntity(page, {
+        type: 'edge',
+        src: 'Ben',
+        dst: 'Pedro',
+        layers: ['meets', 'founds', 'transfers'],
+    });
+    await page
+        .getByRole('button', { name: 'Ben - Pedro Layers: meets' })
+        .click();
+    await page.getByRole('button', { name: 'Edge Statistics' }).click();
+    await page.getByRole('button', { name: 'Open', exact: true }).click();
+    await page.getByRole('link', { name: 'Ben' }).click();
+    await page.waitForSelector('text=Overview');
+    await expect(page).toHaveURL(
+        '/graph?baseGraph=vanilla%2Fevent&initialNodes=%5B%22Ben%22%5D',
+    );
+});
+
+test('Search for relationships in certain date range', async ({ page }) => {
+    await page.goto('/search');
+    await page
+        .getByRole('button', {
+            name: 'Select a graph',
+        })
+        .click();
+    await page
+        .getByRole('row', { name: /^vanilla$/ })
+        .waitFor({ state: 'visible' });
+    await page.getByRole('row', { name: /^vanilla$/ }).click();
+    await page
+        .getByRole('row', { name: /^event$/ })
+        .waitFor({ state: 'visible' });
+    await page.getByRole('row', { name: /^event$/ }).click();
+    await page
+        .getByRole('button', {
+            name: 'Confirm',
+        })
+        .click();
+    await page
+        .getByRole('button', {
+            name: 'Confirm',
+        })
+        .waitFor({ state: 'hidden' });
+    await page
+        .getByRole('button', {
+            name: 'Choose date, selected date is 1 Jan',
+        })
+        .or(
+            page.getByRole('textbox', {
+                name: 'Choose date, selected date is 1 Jan',
+            }),
+        )
+        .click();
+    await page
+        .getByRole('button', { name: 'calendar view is open, switch' })
+        .click();
+    await page.getByRole('radio', { name: '2023' }).click();
+    await page
+        .getByRole('button', {
+            name: 'Choose date, selected date is 1 Jan',
+        })
+        .or(
+            page.getByRole('textbox', {
+                name: 'Choose date, selected date is 1 Jan',
+            }),
+        )
+        .click();
+    for (let i = 0; i < 10; i++) {
+        await page.getByRole('button', { name: 'Next month' }).click();
+    }
+    await page
+        .getByRole('row', { name: '1 2 3 4 5', exact: true })
+        .locator('button')
+        .first()
+        .click();
+    await page.getByRole('combobox').filter({ hasText: 'Entity' }).click();
+    await page.getByRole('option', { name: 'Relationship' }).click();
+    await page.getByRole('textbox', { name: 'Source ID' }).click();
+    await page.getByRole('textbox', { name: 'Source ID' }).fill('Hamza');
+    await page.getByRole('textbox', { name: 'Destination ID' }).click();
+    await page.getByRole('textbox', { name: 'Destination ID' }).fill('Pedro');
+    await page.getByRole('button', { name: 'Search', exact: true }).click();
+    await page.getByRole('button', { name: 'Hamza - Pedro Layers:' }).click();
+    await page.getByRole('button', { name: 'Edge Statistics' }).click();
+    await expect(page.getByText('meets, transfers')).toBeVisible();
+});
+
+test('Search for conditions in query builder', async ({ page }) => {
+    await searchForEntity(page, {
+        type: 'node',
+        nodeType: 'Person',
+        conditions: [{ name: 'age', value: '28' }],
+    });
+
+    const table = page.getByRole('table');
+    await expect(table).toBeVisible();
+    const rows = table.locator('tbody tr');
+    await expect(rows).toHaveCount(1);
+});
+
+test('Delete condition in query builder', async ({ page }) => {
+    await searchForEntity(page, {
+        type: 'node',
+        nodeType: 'Company',
+        conditions: [{ name: 'ID', value: 'Pom' }],
+    });
+    await page.getByText('Nothing turned up!').isVisible();
+    await page
+        .locator(
+            '.MuiButtonBase-root.MuiIconButton-root.MuiIconButton-sizeMedium.css-g6vrc0-MuiButtonBase-root-MuiIconButton-root',
+        )
+        .click();
+    await page.getByRole('button', { name: 'Search', exact: true }).click();
+    await waitForLayoutToFinish(page);
+    await expect(page.getByRole('table')).toBeVisible();
+    await expect(page.getByRole('table').locator('tbody tr')).toHaveCount(1);
+});
+
+test('is, is not condition statements in query builder', async ({ page }) => {
+    test.setTimeout(60000);
+    await searchForEntity(page, {
+        type: 'node',
+        nodeType: 'Person',
+        conditions: [{ name: 'ID', value: 'Pedro' }],
+    });
+    await waitForLayoutToFinish(page);
+    await expect(page.getByRole('table')).toBeVisible();
+    await expect(page.getByRole('table').locator('tbody tr')).toHaveCount(1);
+
+    await fillInCondition(page, {
+        op: { current: 'Is', new: 'Is Not' },
+        value: 'Pedro',
+    });
+    await page.getByRole('button', { name: 'Search', exact: true }).click();
+    await waitForLayoutToFinish(page);
+    await expect(page.getByRole('table')).toBeVisible();
+    await expect(page.getByRole('table').locator('tbody tr')).toHaveCount(2);
+});
+
+test('includes, excludes condition statements in query builder', async ({
+    page,
+}) => {
+    test.setTimeout(60000);
+    await searchForEntity(page, {
+        type: 'node',
+        nodeType: 'Person',
+        conditions: [
+            { name: 'ID', op: { current: 'Is', new: 'Includes' }, value: 'Pe' },
+        ],
+    });
+    await waitForLayoutToFinish(page);
+    await expect(page.getByRole('table').locator('tbody tr')).toHaveCount(1);
+
+    await fillInCondition(page, {
+        op: { current: 'Includes', new: 'Excludes' },
+        value: 'Pe',
+    });
+    await page.getByRole('button', { name: 'Search', exact: true }).click();
+    await waitForLayoutToFinish(page);
+    await expect(page.getByRole('table').locator('tbody tr')).toHaveCount(2);
+});
diff --git a/ui-tests/tests/e2e/temporalview.spec.ts b/ui-tests/tests/e2e/temporalview.spec.ts
new file mode 100644
index 0000000000..5c7bf28701
--- /dev/null
+++ b/ui-tests/tests/e2e/temporalview.spec.ts
@@ -0,0 +1,155 @@
+import { expect, Page, test } from '@playwright/test';
+import { navigateToSavedGraphBySavedGraphsTable } from './utils';
+
+async function setupGraphPage(
+    page: Page,
+    relativePath = 'graph?graphSource=vanilla/event&initialNodes=%5B%5D',
+) {
+    await page.goto(`/${relativePath}`);
+    await page.waitForSelector('text=Ben');
+    return page;
+}
+
+async function hoverEdgeAndExpectTooltip(
+    page: Page,
+    selector: string,
+    expectedText: string,
+) {
+    const line = page.locator(selector).first();
+    await expect(line).toHaveCount(1);
+
+    const box = await line.boundingBox();
+    if (!box) throw new Error(`Element ${selector} is not visible or rendered`);
+    await page.mouse.move(250, 200);
+    await page.mouse.move(box.x + box.width / 2, box.y + box.height / 2);
+    await expect(page.getByText(expectedText)).toBeVisible();
+}
+
+test('Close temporal view button and open again', async ({ page }) => {
+    await setupGraphPage(page);
+    await page.waitForSelector('text=Ben');
+    await page
+        .locator(
+            '.MuiButtonBase-root.MuiButton-root.MuiButton-text.MuiButton-textPrimary',
+        )
+        .nth(6)
+        .click();
+
+    await expect(page.locator('text="Ben"')).toBeHidden();
+
+    await page
+        .locator(
+            '.MuiButtonBase-root.MuiButton-root.MuiButton-text.MuiButton-textPrimary',
+        )
+        .nth(6)
+        .click();
+    await page.waitForSelector('text=Ben');
+    await expect(page.locator('text="Ben"')).toBeVisible();
+});
+
+test('Temporal view hover over edges', async ({ page }) => {
+    await setupGraphPage(page);
+    await hoverEdgeAndExpectTooltip(
+        page,
+        'g:nth-child(20) > line:nth-child(6)',
+        'Ben -> meets -> Hamza',
+    );
+    await hoverEdgeAndExpectTooltip(
+        page,
+        'g:nth-child(19) > line:nth-child(6)',
+        'Ben -> meets -> Pedro',
+    );
+    await hoverEdgeAndExpectTooltip(
+        page,
+        'g:nth-child(22) > line:nth-child(6)',
+        'Hamza -> founds -> Pometry',
+    );
+    await hoverEdgeAndExpectTooltip(
+        page,
+        'g:nth-child(23) > line:nth-child(6)',
+        'Hamza -> meets -> Pedro',
+    );
+    await hoverEdgeAndExpectTooltip(
+        page,
+        'g:nth-child(24) > line:nth-child(6)',
+        'Hamza -> meets -> Pedro',
+    );
+    await hoverEdgeAndExpectTooltip(
+        page,
+        'g:nth-child(25) > line:nth-child(6)',
+        'Hamza -> transfers -> Pedro',
+    );
+    await hoverEdgeAndExpectTooltip(
+        page,
+        'g:nth-child(18) > line:nth-child(6)',
+        'Pedro -> transfers -> Hamza',
+    );
+    await hoverEdgeAndExpectTooltip(
+        page,
+        'g:nth-child(21) > line:nth-child(6)',
+        'Ben -> transfers -> Hamza',
+    );
+});
+
+test('Pin node and highlight', async ({ page }) => {
+    navigateToSavedGraphBySavedGraphsTable(page, 'vanilla', 'event');
+    await page.waitForSelector('text=Pedro');
+    await page
+        .locator('g')
+        .filter({ hasText: /^Pometry$/ })
+        .locator('image')
+        .click();
+    expect(await page.screenshot()).toMatchSnapshot('pinnode.png', {
+        maxDiffPixels: 3500,
+    });
+    await page
+        .locator('g')
+        .filter({ hasText: /^Pometry$/ })
+        .locator('circle')
+        .click();
+    expect(await page.screenshot()).toMatchSnapshot(
+        'highlightedandpinned.png',
+        {
+            maxDiffPixels: 3500,
+        },
+    );
+});
+
+test('Zoom into timeline view', async ({ page }) => {
+    await setupGraphPage(page);
+    await page.waitForSelector('text="Pometry"');
+    const element = page.locator(
+        '.MuiPaper-root.MuiPaper-elevation.MuiPaper-rounded.MuiPaper-elevation1.css-gnkdhv-MuiPaper-root',
+    );
+    await expect(element).toBeVisible();
+    const box = await element.boundingBox();
+    if (box !== null) {
+        const offsetX = box.width / 2;
+        const offsetY = box.height / 2;
+
+        await page.mouse.move(box.x + offsetX, box.y + offsetY);
+        await page.mouse.wheel(0, -2000); // scroll up (zoom in)
+        await expect(page.getByText('Pedro')).toBeHidden();
+    }
+});
+
+test('Highlight node from timeline view', async ({ page }) => {
+    navigateToSavedGraphBySavedGraphsTable(page, 'vanilla', 'event');
+    await page
+        .locator('g')
+        .filter({ hasText: /^Ben$/ })
+        .locator('circle')
+        .click();
+    await page.getByRole('tab', { name: 'Selected' }).click();
+    await page.getByRole('button', { name: 'Node Statistics' }).click();
+    await page.getByRole('row', { name: 'Node Type Person' }).isVisible();
+    await page
+        .locator('g')
+        .filter({ hasText: /^Hamza$/ })
+        .locator('circle')
+        .click({
+            modifiers: ['Shift'],
+        });
+    await page.getByRole('button', { name: 'Node Statistics' }).click();
+    await page.getByRole('row', { name: 'Node Type Person' }).isVisible();
+});
diff --git a/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/highlightedandpinned-chromium-darwin.png b/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/highlightedandpinned-chromium-darwin.png
new file mode 100644
index 0000000000..7d6c53900c
Binary files /dev/null and b/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/highlightedandpinned-chromium-darwin.png differ
diff --git a/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/highlightedandpinned-chromium-linux.png b/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/highlightedandpinned-chromium-linux.png
new file mode 100644
index 0000000000..cb90e5ef12
Binary files /dev/null and b/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/highlightedandpinned-chromium-linux.png differ
diff --git a/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/highlightedandpinned-firefox-darwin.png b/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/highlightedandpinned-firefox-darwin.png
new file mode 100644
index 0000000000..cf889c33d8
Binary files /dev/null and b/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/highlightedandpinned-firefox-darwin.png differ
diff --git a/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/highlightedandpinned-firefox-linux.png b/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/highlightedandpinned-firefox-linux.png
new file mode 100644
index 0000000000..db4775ff45
Binary files /dev/null and b/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/highlightedandpinned-firefox-linux.png differ
diff --git a/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/highlightedandpinned-webkit-darwin.png b/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/highlightedandpinned-webkit-darwin.png
new file mode 100644
index 0000000000..56267f6686
Binary files /dev/null and b/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/highlightedandpinned-webkit-darwin.png differ
diff --git a/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/highlightedandpinned-webkit-linux.png b/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/highlightedandpinned-webkit-linux.png
new file mode 100644
index 0000000000..9ace61eaf5
Binary files /dev/null and b/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/highlightedandpinned-webkit-linux.png differ
diff --git a/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/pinnode-chromium-darwin.png b/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/pinnode-chromium-darwin.png
new file mode 100644
index 0000000000..44f59fbb7c
Binary files /dev/null and b/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/pinnode-chromium-darwin.png differ
diff --git a/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/pinnode-chromium-linux.png b/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/pinnode-chromium-linux.png
new file mode 100644
index 0000000000..8a6e4e7d58
Binary files /dev/null and b/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/pinnode-chromium-linux.png differ
diff --git a/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/pinnode-firefox-darwin.png b/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/pinnode-firefox-darwin.png
new file mode 100644
index 0000000000..73952cf836
Binary files /dev/null and b/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/pinnode-firefox-darwin.png differ
diff --git a/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/pinnode-firefox-linux.png b/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/pinnode-firefox-linux.png
new file mode 100644
index 0000000000..dd237ad644
Binary files /dev/null and b/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/pinnode-firefox-linux.png differ
diff --git a/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/pinnode-webkit-darwin.png b/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/pinnode-webkit-darwin.png
new file mode 100644
index 0000000000..61943c51f0
Binary files /dev/null and b/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/pinnode-webkit-darwin.png differ
diff --git a/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/pinnode-webkit-linux.png b/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/pinnode-webkit-linux.png
new file mode 100644
index 0000000000..5900efb90c
Binary files /dev/null and b/ui-tests/tests/e2e/temporalview.spec.ts-snapshots/pinnode-webkit-linux.png differ
diff --git a/ui-tests/tests/e2e/utils.ts b/ui-tests/tests/e2e/utils.ts
new file mode 100644
index 0000000000..a8af27d442
--- /dev/null
+++ b/ui-tests/tests/e2e/utils.ts
@@ -0,0 +1,181 @@
+import { expect, Page } from '@playwright/test';
+
+export async function fillInCondition(
+    page: Page,
+    condition: {
+        op?: { current: string; new: string };
+        value?: string;
+    },
+) {
+    if (condition.op !== undefined) {
+        await page
+            .getByRole('combobox', { name: condition.op.current })
+            .click();
+        await expect(
+            page.getByRole('option', { name: condition.op.new }),
+        ).toBeVisible();
+        await page.getByRole('option', { name: condition.op.new }).click();
+        await expect(
+            page.getByRole('combobox', { name: condition.op.new }),
+        ).toBeVisible();
+    }
+    if (condition.value !== undefined) {
+        const input = page.getByPlaceholder('Value');
+        await input.focus();
+        await input.fill(condition.value);
+        await input.press('Tab'); // tab is required for blur events
+    }
+}
+
+export async function searchForEntity(
+    page: Page,
+    entity:
+        | {
+              type: 'node';
+              nodeType: string;
+              conditions?: {
+                  name: string;
+                  op?: { current: string; new: string };
+                  value?: string;
+              }[];
+          }
+        | {
+              type: 'edge';
+              src?: string;
+              dst?: string;
+              layers?: string[];
+          },
+) {
+    await page.goto('/search');
+    await page
+        .getByRole('button', {
+            name: 'Select a graph',
+        })
+        .click();
+    await page.waitForSelector('text="vanilla"');
+    await page.getByRole('row', { name: /^vanilla$/ }).click();
+    await page.waitForSelector('text="event"');
+    await page.getByRole('row', { name: /^event$/ }).click();
+    await page
+        .getByRole('button', {
+            name: 'Confirm',
+        })
+        .click();
+    if (entity.type === 'node') {
+        await page.getByRole('combobox', { name: 'Select type' }).click();
+        await page.getByRole('option', { name: entity.nodeType }).click();
+        await expect(page.getByText(entity.nodeType).first()).toBeVisible();
+        for (const condition of entity.conditions ?? []) {
+            await page
+                .locator('div')
+                .filter({
+                    hasText: new RegExp(
+                        `^With the following conditions:${entity.nodeType}$`,
+                    ),
+                })
+                .getByRole('button')
+                .click();
+            await page.getByRole('menuitem', { name: condition.name }).click();
+            await fillInCondition(page, condition);
+        }
+    } else if (entity.type === 'edge') {
+        await page.getByRole('combobox').filter({ hasText: 'Entity' }).click();
+        await page.getByRole('option', { name: 'Relationship' }).click();
+        if (entity.src !== undefined) {
+            await page.getByRole('textbox', { name: 'Source ID' }).click();
+            await page
+                .getByRole('textbox', { name: 'Source ID' })
+                .fill(entity.src);
+        }
+        if (entity.dst !== undefined) {
+            await page.getByRole('textbox', { name: 'Destination ID' }).click();
+            await page
+                .getByRole('textbox', { name: 'Destination ID' })
+                .fill(entity.dst);
+        }
+        for (const layer of entity.layers ?? []) {
+            await page.getByRole('combobox', { name: 'Layers' }).click();
+            await page.getByRole('option', { name: layer }).click();
+        }
+    }
+    await page.getByRole('button', { name: 'Search', exact: true }).click();
+}
+
+export async function navigateToGraphPageBySearch(
+    page: Page,
+    entity:
+        | {
+              type: 'node';
+              nodeName: string;
+              nodeType: string;
+          }
+        | {
+              type: 'edge';
+              src: string;
+              dst: string;
+              layers: string[];
+          },
+) {
+    await searchForEntity(page, entity);
+
+    if (entity.type === 'node') {
+        if (entity.nodeType === 'Person') {
+            await page
+                .getByRole('button', { name: `${entity.nodeName} Age` })
+                .dblclick();
+        } else if (entity.nodeType === 'Company') {
+            await page
+                .getByRole('button', {
+                    name: `${entity.nodeName} No properties found`,
+                })
+                .dblclick();
+        }
+    } else if (entity.type === 'edge') {
+        await page
+            .getByRole('button', {
+                name: `${entity.src} - ${entity.dst} Layers: ${entity.layers.join(',')}`,
+            })
+            .dblclick();
+    }
+
+    await waitForLayoutToFinish(page);
+}
+
+export async function selectLayout(
+    page: Page,
+    layoutName: string,
+    layoutTimeout?: number,
+) {
+    await page.getByRole('button', { name: 'Layout' }).click();
+    await page
+        .getByRole('menuitem', {
+            name: layoutName,
+            exact: true,
+        })
+        .click();
+    await waitForLayoutToFinish(page, layoutTimeout);
+}
+
+export async function waitForLayoutToFinish(
+    page: Page,
+    layoutTimeout?: number,
+) {
+    await expect(page.getByRole('progressbar')).toBeHidden({
+        timeout: layoutTimeout,
+    });
+    // this extra timeout is to account for the animation
+    await page.waitForTimeout(2000);
+}
+
+export async function navigateToSavedGraphBySavedGraphsTable(
+    page: Page,
+    folderName: string,
+    graphName: string,
+) {
+    await page.goto('/saved-graphs');
+    await page
+        .getByRole('row', { name: new RegExp(`^${folderName}$`) })
+        .click();
+    await page.getByRole('cell', { name: graphName }).dblclick();
+    await page.waitForSelector('text=Ben');
+}
diff --git a/ui-tests/tsconfig.json b/ui-tests/tsconfig.json
new file mode 100644
index 0000000000..5d46d72fae
--- /dev/null
+++ b/ui-tests/tsconfig.json
@@ -0,0 +1,27 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "useDefineForClassFields": true,
+        "lib": ["ES2023", "DOM", "DOM.Iterable"],
+        "module": "ESNext",
+        "skipLibCheck": true,
+        /* Bundler mode */
+        "moduleResolution": "bundler",
+        "allowImportingTsExtensions": true,
+        "resolveJsonModule": true,
+        "isolatedModules": true,
+        "declaration": true,
+        "emitDeclarationOnly": true,
+        "outDir": "types",
+        /* Linting */
+        "strict": true,
+        "noUnusedLocals": true,
+        "noUnusedParameters": true,
+        "noFallthroughCasesInSwitch": true,
+        // "noUncheckedIndexedAccess": true // TODO: enable this
+
+        "types": ["node"]
+    },
+    "include": ["tests"],
+    "exclude": ["node_modules"]
+}