diff --git a/.github/dependabot.yml b/.github/dependabot.yml new file mode 100644 index 0000000..6203c8b --- /dev/null +++ b/.github/dependabot.yml @@ -0,0 +1,32 @@ +version: 2 + +updates: + # Security fixes arrive as dependency bumps, so an unattended project needs + # something that opens the pull request on its own. + - package-ecosystem: cargo + directory: "/" + schedule: + interval: weekly + day: saturday + time: "08:00" + timezone: Europe/Paris + open-pull-requests-limit: 5 + groups: + minor-and-patch: + update-types: [minor, patch] + + # The actions in the workflows are dependencies too, and the ones that go + # stale quietly are the ones nobody thinks of. + - package-ecosystem: github-actions + directory: "/" + schedule: + interval: weekly + day: saturday + time: "08:00" + timezone: Europe/Paris + ignore: + # The branches of this action are toolchain names, not releases: @stable + # installs stable and @1.97 installs 1.97. Dependabot reads the second as + # a version and offers to raise it, which would quietly stop the job from + # testing the minimum toolchain Cargo.toml promises. + - dependency-name: dtolnay/rust-toolchain diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md new file mode 100644 index 0000000..4fa2451 --- /dev/null +++ b/.github/pull_request_template.md @@ -0,0 +1,8 @@ + + +## Checklist + +- [ ] `cargo test`, `cargo clippy --all-targets -- -D warnings` and `cargo fmt --all -- --check` pass +- [ ] The window builds what it shows: no picture or drawing fetched or committed, no one else's data in the repository +- [ ] Everything the window shows is in English +- [ ] The README says what changed, if it changes what cellstage shows or how it runs diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..2380d3a --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,110 @@ +name: CI + +on: + push: + branches: [main] + pull_request: + +# A new push replaces the run it supersedes instead of queueing behind it. +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +# The workflow only reads the repository. Nothing here needs write access. +permissions: + contents: read + +env: + CARGO_TERM_COLOR: always + # A warning that nobody reads is a warning that does not exist. + RUSTFLAGS: -D warnings + +jobs: + lint: + name: Format, lints and docs + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v7 + - uses: dtolnay/rust-toolchain@stable + with: + components: rustfmt, clippy + - uses: Swatinem/rust-cache@v2 + + # What winit links against to open a window on Linux. + - name: System libraries + run: | + sudo apt-get update + sudo apt-get install --yes --no-install-recommends libwayland-dev libxkbcommon-dev + + - name: Formatting + run: cargo fmt --all -- --check + + - name: Lints + run: cargo clippy --all-targets + + # Catches broken intra-doc links. + - name: Documentation + run: cargo doc --no-deps + env: + RUSTDOCFLAGS: -D warnings + + # cellstage shows only what it builds, and fetches what it reads, + # proteins and pathways, into the user's cache. Neither someone else's + # data nor a picture nor a drawing belongs in the repository. + - name: No data, pictures or drawings in the repository + run: | + if git ls-files | grep -E -i '\.(csv|tsv|xlsx|xls|parquet|h5|hdf5|mat|pdb|cif|bcif|png|jpe?g|gif|webp|tiff?|svg)$'; then + echo "data, pictures or drawings are committed: cellstage fetches what it reads and builds what it shows" + exit 1 + fi + + test: + name: Tests + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v7 + - uses: dtolnay/rust-toolchain@stable + - uses: Swatinem/rust-cache@v2 + - name: System libraries + run: | + sudo apt-get update + sudo apt-get install --yes --no-install-recommends libwayland-dev libxkbcommon-dev + # No test opens a window or reaches the network, so none needs a display. + - name: Tests + run: cargo test + + msrv: + name: Oldest supported Rust + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v7 + # The ref is the toolchain: this installs Rust 1.97. Keep it in step with + # rust-version in Cargo.toml, which is the value that binds. Dependabot is + # told to leave it alone in dependabot.yml. + - uses: dtolnay/rust-toolchain@1.97 + - uses: Swatinem/rust-cache@v2 + + # The ref above and rust-version state the same fact in two places, and two + # places drift. This makes them disagree loudly instead of leaving the job + # quietly testing a toolchain nobody promised. + - name: The toolchain is the one the manifest promises + run: | + declared=$(sed -n 's/^rust-version *= *"\([^"]*\)".*/\1/p' Cargo.toml | head -1 | cut -d. -f1,2) + installed=$(rustc --version | cut -d' ' -f2 | cut -d. -f1,2) + echo "Cargo.toml says $declared, this runner has $installed" + if [ -z "$declared" ]; then + echo "::error::no rust-version found in Cargo.toml" + exit 1 + fi + if [ "$declared" != "$installed" ]; then + echo "::error::Cargo.toml promises Rust $declared but CI installed $installed" + exit 1 + fi + + - name: System libraries + run: | + sudo apt-get update + sudo apt-get install --yes --no-install-recommends libwayland-dev libxkbcommon-dev + + - name: Build + run: cargo check --all-targets diff --git a/.github/workflows/security.yml b/.github/workflows/security.yml new file mode 100644 index 0000000..199c271 --- /dev/null +++ b/.github/workflows/security.yml @@ -0,0 +1,26 @@ +name: Security + +# Dependencies do not have to change for the news about them to change. An +# advisory published against a crate that has been in Cargo.lock for months is +# exactly the case a push-triggered workflow never catches, hence the schedule. +on: + push: + branches: [main] + pull_request: + schedule: + # Saturday morning, Paris time, in step with dependabot.yml. + - cron: "0 6 * * 6" + workflow_dispatch: + +permissions: + contents: read + +jobs: + deny: + name: Advisories, licences, sources + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v7 + - uses: EmbarkStudios/cargo-deny-action@v2 + with: + command: check diff --git a/.gitignore b/.gitignore index c3ec7d2..bd23b0a 100644 --- a/.gitignore +++ b/.gitignore @@ -22,3 +22,6 @@ rustc-ice-*.txt # and can be added to the global gitignore or merged into this file. For a more nuclear # option (not recommended) you can uncomment the following to ignore the entire idea folder. #.idea/ + +# Cargo settings local to one machine, such as which pkg-config to use +/.cargo diff --git a/Cargo.lock b/Cargo.lock new file mode 100644 index 0000000..295d94f --- /dev/null +++ b/Cargo.lock @@ -0,0 +1,5599 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "ab_glyph" +version = "0.2.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "01c0457472c38ea5bd1c3b5ada5e368271cb550be7a4ca4a0b4634e9913f6cc2" +dependencies = [ + "ab_glyph_rasterizer", + "owned_ttf_parser", +] + +[[package]] +name = "ab_glyph_rasterizer" +version = "0.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "366ffbaa4442f4684d91e2cd7c5ea7c4ed8add41959a31447066e279e432b618" + +[[package]] +name = "accesskit" +version = "0.24.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3b7f7f85a7e5f68090000ed7622545829afd484d210358702ae4cb97dd0c320" +dependencies = [ + "uuid", +] + +[[package]] +name = "accesskit_consumer" +version = "0.38.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d10a236f96f87d70732e44520046785431ef01d5bcd6b041317bfadd2f88245" +dependencies = [ + "accesskit", + "hashbrown 0.16.1", +] + +[[package]] +name = "accesskit_ios" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "750c4e9f6ce888dfe8a10c0f1b5ceb646a7854fd46579d74919219d1bb314083" +dependencies = [ + "accesskit", + "accesskit_consumer", + "hashbrown 0.16.1", + "objc2 0.5.3", + "objc2-foundation 0.2.2", + "objc2-ui-kit", +] + +[[package]] +name = "accesskit_macos" +version = "0.26.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce02dc63b43f0c9296af9ac946312a2dc8814427d7a64d2d600971dac55b6076" +dependencies = [ + "accesskit", + "accesskit_consumer", + "hashbrown 0.16.1", + "objc2 0.5.3", + "objc2-app-kit 0.2.2", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "accesskit_windows" +version = "0.34.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "106c2b961215864d1c2e703ee63269c25c4e80a577ffb2c1017b9c17dcdf83a1" +dependencies = [ + "accesskit", + "accesskit_consumer", + "hashbrown 0.16.1", + "static_assertions", + "windows", + "windows-core", +] + +[[package]] +name = "accesskit_winit" +version = "0.33.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d5b41e63a69f36d9f1f41e70464c7e5f72eee485ef26aab19f0b4f86e6c0a84c" +dependencies = [ + "accesskit", + "accesskit_ios", + "accesskit_macos", + "accesskit_windows", + "raw-window-handle", + "winit", +] + +[[package]] +name = "adler2" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa" + +[[package]] +name = "ahash" +version = "0.8.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75" +dependencies = [ + "cfg-if", + "getrandom 0.3.4", + "once_cell", + "version_check", + "zerocopy", +] + +[[package]] +name = "aho-corasick" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba" +dependencies = [ + "memchr", +] + +[[package]] +name = "allocator-api2" +version = "0.2.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923" + +[[package]] +name = "android-activity" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0f2a1bb052857d5dd49572219344a7332b31b76405648eabac5bc68978251bcd" +dependencies = [ + "android-properties", + "bitflags 2.13.2", + "cc", + "jni", + "libc", + "log", + "ndk", + "ndk-context", + "ndk-sys", + "num_enum", + "thiserror 2.0.21", +] + +[[package]] +name = "android-properties" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc7eb209b1518d6bb87b283c20095f5228ecda460da70b44f0802523dea6da04" + +[[package]] +name = "android_log-sys" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "84521a3cf562bc62942e294181d9eef17eb38ceb8c68677bc49f144e4c3d4f8d" + +[[package]] +name = "android_system_properties" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae221649c9976a6f6c56ae1facf410f3ddb33cc661c4b7b61020a912d4237fbc" +dependencies = [ + "libc", +] + +[[package]] +name = "annotate-snippets" +version = "0.12.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b2a5b0a5ab8561c603f16c3b78c24a386b1f70e7fc1b1b1e8c15738828e4a176" +dependencies = [ + "anstyle", + "memchr", + "unicode-width", +] + +[[package]] +name = "anstream" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d" +dependencies = [ + "anstyle", + "anstyle-parse", + "anstyle-query", + "anstyle-wincon", + "colorchoice", + "is_terminal_polyfill", + "utf8parse", +] + +[[package]] +name = "anstyle" +version = "1.0.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000" + +[[package]] +name = "anstyle-parse" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52ce7f38b242319f7cabaa6813055467063ecdc9d355bbb4ce0c68908cd8130e" +dependencies = [ + "utf8parse", +] + +[[package]] +name = "anstyle-query" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc" +dependencies = [ + "windows-sys 0.61.2", +] + +[[package]] +name = "anstyle-wincon" +version = "3.0.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d" +dependencies = [ + "anstyle", + "once_cell_polyfill", + "windows-sys 0.61.2", +] + +[[package]] +name = "anyhow" +version = "1.0.104" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470" + +[[package]] +name = "approx" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cab112f0a86d568ea0e627cc1d6be74a1e9cd55214684db5561995f6dad897c6" +dependencies = [ + "num-traits", +] + +[[package]] +name = "arboard" +version = "3.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aeb9553e62312c8756a5979254fc6d7da8bbeb5986a1e17037fab932f7037917" +dependencies = [ + "clipboard-win", + "log", + "objc2 0.6.5", + "objc2-app-kit 0.3.2", + "objc2-foundation 0.3.2", + "parking_lot", + "percent-encoding", + "windows-sys 0.61.2", + "wl-clipboard-rs", + "x11rb", +] + +[[package]] +name = "arrayref" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb" + +[[package]] +name = "arrayvec" +version = "0.7.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3fb67a6e08acf24fdeccbac2cb6ac4305825bd1f117462e0e6f2f193345ad56" + +[[package]] +name = "as-raw-xcb-connection" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "175571dd1d178ced59193a6fc02dde1b972eb0bc56c892cde9beeceac5bf0f6b" + +[[package]] +name = "ash" +version = "0.38.0+1.3.281" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0bb44936d800fea8f016d7f2311c6a4f97aebd5dc86f09906139ec848cf3a46f" +dependencies = [ + "libloading", +] + +[[package]] +name = "assert_type_match" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f548ad2c4031f2902e3edc1f29c29e835829437de49562d8eb5dc5584d3a1043" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "async-broadcast" +version = "0.7.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "435a87a52755b8f27fcf321ac4f04b2802e337c8c4872923137471ec39c37532" +dependencies = [ + "event-listener", + "event-listener-strategy", + "futures-core", + "pin-project-lite", +] + +[[package]] +name = "async-channel" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "924ed96dd52d1b75e9c1a3e6275715fd320f5f9439fb5a4a11fa51f4221158d2" +dependencies = [ + "concurrent-queue", + "event-listener-strategy", + "futures-core", + "pin-project-lite", +] + +[[package]] +name = "async-executor" +version = "1.14.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f426a31126c735126297bc5ea7a521263c9faff4f63ca415267ee625651c4f37" +dependencies = [ + "async-task", + "concurrent-queue", + "fastrand", + "futures-lite", + "pin-project-lite", + "slab", +] + +[[package]] +name = "async-fs" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8034a681df4aed8b8edbd7fbe472401ecf009251c8b40556b304567052e294c5" +dependencies = [ + "async-lock", + "blocking", + "futures-lite", +] + +[[package]] +name = "async-io" +version = "2.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "456b8a8feb6f42d237746d4b3e9a178494627745c3c56c6ea55d92ba50d026fc" +dependencies = [ + "autocfg", + "cfg-if", + "concurrent-queue", + "futures-io", + "futures-lite", + "parking", + "polling", + "rustix 1.1.5", + "slab", + "windows-sys 0.61.2", +] + +[[package]] +name = "async-lock" +version = "3.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "290f7f2596bd5b78a9fec8088ccd89180d7f9f55b94b0576823bbbdc72ee8311" +dependencies = [ + "event-listener", + "event-listener-strategy", + "pin-project-lite", +] + +[[package]] +name = "async-task" +version = "4.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de" +dependencies = [ + "portable-atomic", +] + +[[package]] +name = "atomic-waker" +version = "1.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0" +dependencies = [ + "portable-atomic", +] + +[[package]] +name = "atomicow" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "301801c08259e328a1c7da556608c0c22687708831b22024dbd3a57ea741e6de" +dependencies = [ + "portable-atomic", + "portable-atomic-util", +] + +[[package]] +name = "autocfg" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53" + +[[package]] +name = "base64" +version = "0.22.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6" + +[[package]] +name = "base64" +version = "0.23.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5" + +[[package]] +name = "bevy" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8bd0e4ea5ec677698955f9f285221eab78606d8c27b57b889def199c16ce36e6" +dependencies = [ + "bevy_internal", +] + +[[package]] +name = "bevy_a11y" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1070b9b7f087a5073be2da713367f29a831c85cd3391afcfc95bc0498125704" +dependencies = [ + "accesskit", + "bevy_app", + "bevy_derive", + "bevy_ecs", + "bevy_reflect", +] + +[[package]] +name = "bevy_android" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "17fd56a4708085b36f8aa1a011e347f8bd9334f0343bb3d5d9c3742897968a55" +dependencies = [ + "android-activity", +] + +[[package]] +name = "bevy_anti_alias" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f4df27fadf88e6ff72bf63a5e80e3921536eabfcde3196db347c31b6bbb39606" +dependencies = [ + "bevy_app", + "bevy_asset", + "bevy_camera", + "bevy_core_pipeline", + "bevy_derive", + "bevy_diagnostic", + "bevy_ecs", + "bevy_extract", + "bevy_image", + "bevy_math", + "bevy_reflect", + "bevy_render", + "bevy_shader", + "bevy_utils", + "tracing", +] + +[[package]] +name = "bevy_app" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a2489da2972d57cccd19060d7faa44c4c4cfb296a657c84ee6ab8bde2b1c0115" +dependencies = [ + "bevy_derive", + "bevy_ecs", + "bevy_platform", + "bevy_reflect", + "bevy_tasks", + "bevy_utils", + "console_error_panic_hook", + "ctrlc", + "downcast-rs 2.0.2", + "log", + "thiserror 2.0.21", + "variadics_please", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "bevy_asset" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b88b3767a2c3f5a017b2febca08a670819ea2acb46846e4d8cd02980aeb0ed3e" +dependencies = [ + "async-broadcast", + "async-channel", + "async-fs", + "async-io", + "async-lock", + "atomicow", + "bevy_android", + "bevy_app", + "bevy_asset_macros", + "bevy_diagnostic", + "bevy_ecs", + "bevy_platform", + "bevy_reflect", + "bevy_tasks", + "bevy_utils", + "bitflags 2.13.2", + "blake3", + "crossbeam-channel", + "derive_more", + "disqualified", + "downcast-rs 2.0.2", + "either", + "futures-io", + "futures-lite", + "futures-util", + "js-sys", + "ron", + "serde", + "stackfuture", + "thiserror 2.0.21", + "tracing", + "uuid", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", +] + +[[package]] +name = "bevy_asset_macros" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "875b4fd236612744dbd61fb0a77ffde0aee37b8b780cf8a89caa308511c70646" +dependencies = [ + "bevy_macro_utils", + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "bevy_camera" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f32c0d8436fb9373dc3b64fa30c3dec51d6a7cfda61de3c70fd1f62f8a903887" +dependencies = [ + "bevy_app", + "bevy_asset", + "bevy_color", + "bevy_derive", + "bevy_ecs", + "bevy_image", + "bevy_math", + "bevy_mesh", + "bevy_reflect", + "bevy_shape", + "bevy_transform", + "bevy_utils", + "bevy_window", + "derive_more", + "downcast-rs 2.0.2", + "serde", + "smallvec", + "thiserror 2.0.21", + "wgpu-types", +] + +[[package]] +name = "bevy_clipboard" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0267b0beafd7e587a1b25b5ce14b271577f5fc1d8fd7828b2b66f0cf5dd649b" +dependencies = [ + "arboard", + "bevy_app", + "bevy_ecs", + "bevy_log", + "bevy_platform", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", +] + +[[package]] +name = "bevy_color" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c0e57bfc1a0da1c018235fb98bb0e15ab61f1d0253122020ab6e1450e6cfbcf9" +dependencies = [ + "bevy_curve", + "bevy_math", + "bevy_reflect", + "bytemuck", + "derive_more", + "encase", + "serde", + "thiserror 2.0.21", + "wgpu-types", +] + +[[package]] +name = "bevy_core_pipeline" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a4a077b301be4b373a4cb224c54988e1f8385ecf3ab9e60bd3727a65b3d6901a" +dependencies = [ + "bevy_app", + "bevy_asset", + "bevy_camera", + "bevy_color", + "bevy_derive", + "bevy_diagnostic", + "bevy_ecs", + "bevy_extract", + "bevy_image", + "bevy_light", + "bevy_log", + "bevy_math", + "bevy_platform", + "bevy_reflect", + "bevy_render", + "bevy_shader", + "bevy_transform", + "bevy_utils", + "bevy_window", + "bitflags 2.13.2", + "indexmap", + "nonmax", +] + +[[package]] +name = "bevy_curve" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "21ae28ed95c1c8a1bfc8930471840ee5a4b99b6b31138b17598e7ee6f4291b64" +dependencies = [ + "approx", + "bevy_math", + "bevy_reflect", + "itertools 0.14.0", + "serde", + "thiserror 2.0.21", + "variadics_please", +] + +[[package]] +name = "bevy_derive" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fd59e9e600d792e60df17b4d52719b28c288bf047884ac89ad29d9c7a6592d2c" +dependencies = [ + "bevy_macro_utils", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "bevy_diagnostic" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f8851dc1b253b350bf941695457007e6e44ad4b8f075bf52a1ef202e6866b6a" +dependencies = [ + "atomic-waker", + "bevy_app", + "bevy_ecs", + "bevy_platform", + "bevy_tasks", + "bevy_time", + "const-fnv1a-hash", + "log", + "serde", +] + +[[package]] +name = "bevy_ecs" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d5541a1658c5029b39e3ec59c6ecb47ad0a6d85fa083312a5ee2a95d6982a926" +dependencies = [ + "arrayvec", + "bevy_ecs_macros", + "bevy_platform", + "bevy_ptr", + "bevy_reflect", + "bevy_tasks", + "bevy_utils", + "bitflags 2.13.2", + "bumpalo", + "concurrent-queue", + "derive_more", + "fixedbitset", + "indexmap", + "log", + "nonmax", + "serde", + "slotmap", + "smallvec", + "thiserror 2.0.21", + "variadics_please", +] + +[[package]] +name = "bevy_ecs_macro_logic" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5197fea7643d2733e8b6d81c3dfa99adad3a754cdfd159c00255cea157b795d7" +dependencies = [ + "bevy_macro_utils", + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "bevy_ecs_macros" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3dde5305169503c9101404bf8cf17e8351f56fccf5152b8e5d7d7c32dcf1c486" +dependencies = [ + "bevy_ecs_macro_logic", + "bevy_macro_utils", + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "bevy_egui" +version = "0.43.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cee91f48e697b0fd853713f81e95299a3f337f4623b1445df5e3da91284f30a3" +dependencies = [ + "bevy_app", + "bevy_asset", + "bevy_camera", + "bevy_color", + "bevy_core_pipeline", + "bevy_derive", + "bevy_ecs", + "bevy_extract", + "bevy_image", + "bevy_input", + "bevy_log", + "bevy_math", + "bevy_mesh", + "bevy_platform", + "bevy_reflect", + "bevy_render", + "bevy_shader", + "bevy_shape", + "bevy_time", + "bevy_transform", + "bevy_utils", + "bevy_window", + "bevy_winit", + "bytemuck", + "crossbeam-channel", + "egui", + "encase", + "getrandom 0.4.3", + "image", + "itertools 0.15.0", + "js-sys", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", + "wgpu-types", + "winit", +] + +[[package]] +name = "bevy_encase_derive" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d4e4c4183c39ae8d00e53afeeab66aa71c41b08d82638149f9d485a2a62df569" +dependencies = [ + "bevy_macro_utils", + "encase_derive_impl", +] + +[[package]] +name = "bevy_extract" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08e27fc07ef8e3ab7c217fed1b171d42c90f3b6e4f7f526ffa28f9006ac49aa4" +dependencies = [ + "bevy_app", + "bevy_camera", + "bevy_derive", + "bevy_ecs", + "bevy_extract_macros", + "bevy_log", + "bevy_platform", + "bevy_reflect", + "bevy_time", + "bevy_utils", +] + +[[package]] +name = "bevy_extract_macros" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a5c67e8c55ef35c65295e8cb614eda169780e21e2748f6df470d3bff21849a3" +dependencies = [ + "bevy_macro_utils", + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "bevy_gizmos" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dfc92f635ec5eaef5733afee45e6a0452e8c65de42d818dc7269dc5265087689" +dependencies = [ + "bevy_app", + "bevy_asset", + "bevy_camera", + "bevy_color", + "bevy_curve", + "bevy_ecs", + "bevy_gizmos_macros", + "bevy_input", + "bevy_log", + "bevy_math", + "bevy_mesh", + "bevy_reflect", + "bevy_shape", + "bevy_time", + "bevy_transform", + "bevy_utils", + "bevy_window", +] + +[[package]] +name = "bevy_gizmos_macros" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "501e72c4ac31caef17ef9e627dee212d2107b95402a891ec6f0fc4107dd0cdf4" +dependencies = [ + "bevy_macro_utils", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "bevy_gizmos_render" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42f5be0c9f114dc9b2c929076517d088e059b971edec5dfff4d5a225df6796df" +dependencies = [ + "bevy_app", + "bevy_asset", + "bevy_camera", + "bevy_color", + "bevy_core_pipeline", + "bevy_ecs", + "bevy_extract", + "bevy_gizmos", + "bevy_image", + "bevy_log", + "bevy_material", + "bevy_math", + "bevy_mesh", + "bevy_pbr", + "bevy_reflect", + "bevy_render", + "bevy_shader", + "bevy_shape", + "bevy_transform", + "bevy_utils", + "bytemuck", + "tracing", +] + +[[package]] +name = "bevy_image" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bb818dd8d705809d54adea08e346edce81a51ddbf06406ddf12a72ee467a3855" +dependencies = [ + "bevy_app", + "bevy_asset", + "bevy_color", + "bevy_ecs", + "bevy_math", + "bevy_platform", + "bevy_reflect", + "bevy_utils", + "bitflags 2.13.2", + "bytemuck", + "futures-lite", + "guillotiere", + "half", + "image", + "rectangle-pack", + "ruzstd", + "serde", + "thiserror 2.0.21", + "tracing", + "wgpu-types", +] + +[[package]] +name = "bevy_input" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "261ca5cc8a0bf228bfe4e841570db18a3ab1d034ce089772b8ec49c163ae74ea" +dependencies = [ + "bevy_app", + "bevy_ecs", + "bevy_math", + "bevy_platform", + "bevy_reflect", + "derive_more", + "log", + "smol_str", + "thiserror 2.0.21", +] + +[[package]] +name = "bevy_input_focus" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "83c81d369d0ab3ec17ba14bab1e07da7cacf3751a3104a93b1a3cd99d887887b" +dependencies = [ + "bevy_app", + "bevy_camera", + "bevy_ecs", + "bevy_input", + "bevy_math", + "bevy_reflect", + "bevy_window", + "log", + "thiserror 2.0.21", +] + +[[package]] +name = "bevy_internal" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a4ed1cb58d1761426a077a8aff55e6a2e0cdfd19e411211d4b0217409330bb84" +dependencies = [ + "bevy_a11y", + "bevy_android", + "bevy_anti_alias", + "bevy_app", + "bevy_asset", + "bevy_camera", + "bevy_clipboard", + "bevy_color", + "bevy_core_pipeline", + "bevy_curve", + "bevy_derive", + "bevy_diagnostic", + "bevy_ecs", + "bevy_extract", + "bevy_gizmos", + "bevy_gizmos_render", + "bevy_image", + "bevy_input", + "bevy_input_focus", + "bevy_light", + "bevy_log", + "bevy_material", + "bevy_math", + "bevy_mesh", + "bevy_pbr", + "bevy_platform", + "bevy_post_process", + "bevy_ptr", + "bevy_reflect", + "bevy_render", + "bevy_shader", + "bevy_shape", + "bevy_state", + "bevy_tasks", + "bevy_time", + "bevy_transform", + "bevy_utils", + "bevy_window", + "bevy_winit", +] + +[[package]] +name = "bevy_light" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "529d5ec7db637bbce7d016b2bfd0798362ad67118de8e9d37aaac24ecb3337cd" +dependencies = [ + "bevy_app", + "bevy_asset", + "bevy_camera", + "bevy_color", + "bevy_curve", + "bevy_ecs", + "bevy_image", + "bevy_log", + "bevy_math", + "bevy_mesh", + "bevy_platform", + "bevy_reflect", + "bevy_shape", + "bevy_transform", + "bevy_utils", + "half", + "smallvec", + "tracing", + "wgpu-types", +] + +[[package]] +name = "bevy_log" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a87d5152292b0e581a589cffb6b7e83e0afe345279d4126545ce7b786bd8a47a" +dependencies = [ + "android_log-sys", + "bevy_app", + "bevy_ecs", + "bevy_platform", + "bevy_utils", + "tracing", + "tracing-log", + "tracing-oslog", + "tracing-subscriber", + "tracing-wasm", +] + +[[package]] +name = "bevy_macro_utils" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c0d03a948df65138e30917d91237797d7e38763135ebacd0f28c891e1a3b2b52" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", + "toml_edit", +] + +[[package]] +name = "bevy_material" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5be7ee4b2f4764e8d58a59afb47a3ba8bae36f955f409f08c658cace2808ef40" +dependencies = [ + "bevy_asset", + "bevy_derive", + "bevy_ecs", + "bevy_material_macros", + "bevy_mesh", + "bevy_platform", + "bevy_reflect", + "bevy_shader", + "bevy_utils", + "encase", + "smallvec", + "thiserror 2.0.21", + "tracing", + "variadics_please", + "wgpu-types", +] + +[[package]] +name = "bevy_material_macros" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "70551fa201e1416ab44968631b7ce6320c194acfdb652a1971ec6882af122333" +dependencies = [ + "bevy_macro_utils", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "bevy_math" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "598cbdcec4d0f0d966905996240ac76f77a644c583f95fb612d4f59f5f649038" +dependencies = [ + "approx", + "bevy_reflect", + "derive_more", + "glam", + "libm", + "rand", + "serde", + "thiserror 2.0.21", + "variadics_please", +] + +[[package]] +name = "bevy_mesh" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09358ac9a3ede5855568c10eaba6bcf126bf86639e786fb21b413457ebec5f26" +dependencies = [ + "bevy_app", + "bevy_asset", + "bevy_derive", + "bevy_ecs", + "bevy_encase_derive", + "bevy_math", + "bevy_mikktspace", + "bevy_platform", + "bevy_reflect", + "bevy_shape", + "bevy_transform", + "bitflags 2.13.2", + "bytemuck", + "derive_more", + "encase", + "glam", + "half", + "hexasphere", + "thiserror 2.0.21", + "tracing", + "wgpu-types", +] + +[[package]] +name = "bevy_mikktspace" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bff34eb29ff4b8a8688bc7299f14fb6b597461ca80fec03ed7d22939ab33e48f" + +[[package]] +name = "bevy_pbr" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fb760932d1e683e7c00011f5c99e4e1cc893646a3a7b7224da6daf9bfa94853d" +dependencies = [ + "arrayvec", + "bevy_app", + "bevy_asset", + "bevy_camera", + "bevy_color", + "bevy_core_pipeline", + "bevy_derive", + "bevy_diagnostic", + "bevy_ecs", + "bevy_extract", + "bevy_image", + "bevy_light", + "bevy_log", + "bevy_material", + "bevy_math", + "bevy_mesh", + "bevy_platform", + "bevy_reflect", + "bevy_render", + "bevy_shader", + "bevy_shape", + "bevy_tasks", + "bevy_transform", + "bevy_utils", + "bitflags 2.13.2", + "bytemuck", + "derive_more", + "fixedbitset", + "indexmap", + "nonmax", + "offset-allocator", + "smallvec", + "static_assertions", + "thiserror 2.0.21", + "tracing", + "wgpu-types", +] + +[[package]] +name = "bevy_platform" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "000bc467d1b344b6609fcf217a9b08d349d49c8e85dc4179fb7656f2b6e3db47" +dependencies = [ + "bytemuck", + "critical-section", + "foldhash 0.2.0", + "futures-channel", + "futures-lite", + "hashbrown 0.16.1", + "js-sys", + "portable-atomic", + "portable-atomic-util", + "serde", + "spin", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-time", + "windows-sys 0.61.2", +] + +[[package]] +name = "bevy_post_process" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d684c2ac93e94d9b7ba767ce02ea435ef244677a24746241726de2aa552ba1a4" +dependencies = [ + "bevy_app", + "bevy_asset", + "bevy_camera", + "bevy_color", + "bevy_core_pipeline", + "bevy_curve", + "bevy_derive", + "bevy_ecs", + "bevy_extract", + "bevy_image", + "bevy_math", + "bevy_platform", + "bevy_reflect", + "bevy_render", + "bevy_shader", + "bevy_utils", + "smallvec", + "thiserror 2.0.21", + "tracing", +] + +[[package]] +name = "bevy_ptr" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41935a00c02004753bd7ed5094754397800b3f673bf15553bb007b06216872d5" + +[[package]] +name = "bevy_reflect" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "46eecc733575b873deedcc37639e36290092388657091b3321fa6e073e7818e6" +dependencies = [ + "assert_type_match", + "bevy_platform", + "bevy_ptr", + "bevy_reflect_derive", + "bevy_utils", + "derive_more", + "disqualified", + "downcast-rs 2.0.2", + "erased-serde", + "foldhash 0.2.0", + "glam", + "indexmap", + "inventory", + "serde", + "smallvec", + "smol_str", + "thiserror 2.0.21", + "uuid", + "variadics_please", + "wgpu-types", +] + +[[package]] +name = "bevy_reflect_derive" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dfaa1e315676c625ed8d30ba8a671ebf917cad6355320295b9802a8cbc06853b" +dependencies = [ + "bevy_macro_utils", + "indexmap", + "proc-macro2", + "quote", + "syn 2.0.119", + "uuid", +] + +[[package]] +name = "bevy_render" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f438a921fd3ef82cc09ccf5e0cd8f1214dcae6286890f9d4acba0409d9a61a8" +dependencies = [ + "async-channel", + "bevy_app", + "bevy_asset", + "bevy_camera", + "bevy_color", + "bevy_derive", + "bevy_diagnostic", + "bevy_ecs", + "bevy_encase_derive", + "bevy_extract", + "bevy_extract_macros", + "bevy_image", + "bevy_log", + "bevy_material", + "bevy_material_macros", + "bevy_math", + "bevy_mesh", + "bevy_platform", + "bevy_reflect", + "bevy_render_macros", + "bevy_shader", + "bevy_shape", + "bevy_tasks", + "bevy_time", + "bevy_transform", + "bevy_utils", + "bevy_window", + "bitflags 2.13.2", + "bytemuck", + "derive_more", + "downcast-rs 2.0.2", + "encase", + "glam", + "image", + "indexmap", + "itertools 0.14.0", + "js-sys", + "nonmax", + "offset-allocator", + "send_wrapper", + "smallvec", + "static_assertions", + "thiserror 2.0.21", + "tracing", + "variadics_please", + "wasm-bindgen", + "weak-table", + "web-sys", + "wgpu", + "wgpu-types", +] + +[[package]] +name = "bevy_render_macros" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "119ca6d445eba5c9976c658f29bac854094b27c27624aa92c4d9668c319618d0" +dependencies = [ + "bevy_extract_macros", + "bevy_macro_utils", + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "bevy_shader" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2becafd54079da13835d6a42fc743e305d6270c27a91de613afe6e3f4b5de19" +dependencies = [ + "bevy_asset", + "bevy_platform", + "bevy_reflect", + "bevy_utils", + "serde", + "thiserror 2.0.21", + "tracing", + "wesl", + "wgpu-types", +] + +[[package]] +name = "bevy_shape" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aa8b6096ad1ec7dfe1af8e51d7cfa7de1a9e0a3bd02be58a061092c5e1ff1eb1" +dependencies = [ + "arrayvec", + "bevy_math", + "bevy_reflect", + "derive_more", + "rand", + "rand_distr", + "serde", + "thiserror 2.0.21", +] + +[[package]] +name = "bevy_state" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09292e08e1eb34d2dd915630fb3c04ba75220c7819943c9f213d3a5f9a8be1e8" +dependencies = [ + "bevy_app", + "bevy_ecs", + "bevy_platform", + "bevy_reflect", + "bevy_state_macros", + "bevy_utils", + "log", + "variadics_please", +] + +[[package]] +name = "bevy_state_macros" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fec1a8f6a253e39ddf7e447b1b9286caacb205ed8e619e6fb9a2e010d58dd04b" +dependencies = [ + "bevy_macro_utils", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "bevy_tasks" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fbd8116f12dc50bde3758a72fba85e1f4c00e6c66d0ad58bdc46c0c0690829a8" +dependencies = [ + "async-channel", + "async-executor", + "async-task", + "atomic-waker", + "bevy_platform", + "concurrent-queue", + "crossbeam-queue", + "derive_more", + "futures-lite", + "heapless", + "web-task", +] + +[[package]] +name = "bevy_time" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13901174b792bb7848d8e088075f0009ea409b99179934c0d5bdd2b95622694e" +dependencies = [ + "bevy_app", + "bevy_ecs", + "bevy_platform", + "bevy_reflect", + "crossbeam-channel", + "log", + "serde", +] + +[[package]] +name = "bevy_transform" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "83379023d77a0739569a5bcb859eed652781a1b3271e94a86dfbb56fc5d067e0" +dependencies = [ + "bevy_app", + "bevy_ecs", + "bevy_math", + "bevy_reflect", + "bevy_tasks", + "bevy_utils", + "derive_more", + "serde", + "thiserror 2.0.21", +] + +[[package]] +name = "bevy_utils" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5cbd58495039d4e63e6fcfef1242fecab33ffe62b4a5e010467e69e790879812" +dependencies = [ + "async-channel", + "bevy_platform", + "disqualified", + "indexmap", + "thread_local", +] + +[[package]] +name = "bevy_window" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc9a83f3cbaa04155b5dc9b247819c0e215aee754451a4324b82ddeb80dc53f1" +dependencies = [ + "bevy_app", + "bevy_ecs", + "bevy_input", + "bevy_math", + "bevy_platform", + "bevy_reflect", + "log", + "raw-window-handle", + "serde", +] + +[[package]] +name = "bevy_winit" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ef0a5a55524e793ab13536ef244229fa66a4839fae6564df2aa4b3c13956a82" +dependencies = [ + "accesskit", + "accesskit_winit", + "approx", + "bevy_a11y", + "bevy_android", + "bevy_app", + "bevy_derive", + "bevy_ecs", + "bevy_input", + "bevy_input_focus", + "bevy_log", + "bevy_math", + "bevy_platform", + "bevy_reflect", + "bevy_tasks", + "bevy_window", + "js-sys", + "tracing", + "wasm-bindgen", + "web-sys", + "winit", +] + +[[package]] +name = "bit-set" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2f926cc3060f09db9ebc5b52823d85268d24bb917e472c0c4bea35780a7d" +dependencies = [ + "bit-vec", +] + +[[package]] +name = "bit-vec" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b71798fca2c1fe1086445a7258a4bc81e6e49dcd24c8d0dd9a1e57395b603f51" + +[[package]] +name = "bitflags" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" + +[[package]] +name = "bitflags" +version = "2.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06" +dependencies = [ + "bytemuck", + "serde_core", +] + +[[package]] +name = "blake3" +version = "1.8.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d9e454fc11f76977dc803893aff6304ed33d6a26efae8696573bea74baa27ae" +dependencies = [ + "arrayvec", + "cc", + "cfg-if", + "constant_time_eq", + "cpufeatures", +] + +[[package]] +name = "block2" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2c132eebf10f5cad5289222520a4a058514204aed6d791f1cf4fe8088b82d15f" +dependencies = [ + "objc2 0.5.3", +] + +[[package]] +name = "block2" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cdeb9d870516001442e364c5220d3574d2da8dc765554b4a617230d33fa58ef5" +dependencies = [ + "objc2 0.6.5", +] + +[[package]] +name = "blocking" +version = "1.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a70e4329df6cb94385eed412ec92375c3cdd8a6e502493d1229b6414e4036dfa" +dependencies = [ + "async-channel", + "async-task", + "futures-io", + "futures-lite", + "piper", +] + +[[package]] +name = "bumpalo" +version = "3.20.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649" + +[[package]] +name = "bytemuck" +version = "1.25.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "95832e849adfb21180ccb6826a99da14e5d266ae5c2e668e1602cf234f153797" +dependencies = [ + "bytemuck_derive", +] + +[[package]] +name = "bytemuck_derive" +version = "1.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6a1f896587b6f2c069c73d2f0913e2d590c3990285cd2f0b6aa02b786b4c679c" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.9", +] + +[[package]] +name = "byteorder" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" + +[[package]] +name = "byteorder-lite" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495" + +[[package]] +name = "bytes" +version = "1.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04" + +[[package]] +name = "calloop" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b99da2f8558ca23c71f4fd15dc57c906239752dd27ff3c00a1d56b685b7cbfec" +dependencies = [ + "bitflags 2.13.2", + "log", + "polling", + "rustix 0.38.44", + "slab", + "thiserror 1.0.69", +] + +[[package]] +name = "calloop-wayland-source" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "95a66a987056935f7efce4ab5668920b5d0dac4a7c99991a67395f13702ddd20" +dependencies = [ + "calloop", + "rustix 0.38.44", + "wayland-backend", + "wayland-client", +] + +[[package]] +name = "cc" +version = "1.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "86e055fa6e3e40ad6187ba25b6855eeb635d5271f8e0f0e1e9a5826b8d75bea0" +dependencies = [ + "find-msvc-tools", + "jobserver", + "libc", + "shlex", +] + +[[package]] +name = "cellstage" +version = "0.1.0" +dependencies = [ + "anyhow", + "base64 0.22.1", + "bevy", + "bevy_egui", + "cellweave-core", + "cellweave-engine", + "cellweave-io", + "png", + "rayon", + "serde", + "serde_json", + "ureq", +] + +[[package]] +name = "cellweave-core" +version = "0.3.0" +source = "git+https://github.com/ngodzik/cellweave?tag=v0.3.0#29391b77348f81a445ab3c5bc8731ca322941285" +dependencies = [ + "serde", + "thiserror 2.0.21", +] + +[[package]] +name = "cellweave-engine" +version = "0.3.0" +source = "git+https://github.com/ngodzik/cellweave?tag=v0.3.0#29391b77348f81a445ab3c5bc8731ca322941285" +dependencies = [ + "cellweave-core", + "ndarray", + "rand", + "rayon", + "thiserror 2.0.21", + "tracing", +] + +[[package]] +name = "cellweave-io" +version = "0.3.0" +source = "git+https://github.com/ngodzik/cellweave?tag=v0.3.0#29391b77348f81a445ab3c5bc8731ca322941285" +dependencies = [ + "anyhow", + "cellweave-core", + "cellweave-engine", + "serde", + "serde_json", + "thiserror 2.0.21", + "toml", + "tracing", +] + +[[package]] +name = "cfg-if" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600" + +[[package]] +name = "cfg_aliases" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f079e83a288787bcd14a6aea84cee5c87a67c5a3e660c30f557a3d24761b3527" + +[[package]] +name = "chacha20" +version = "0.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65c35e4b699c7e15ccbe7ee35c005e4fc0a278d22238a2857e6ce2dadeda1b06" +dependencies = [ + "cfg-if", + "cpufeatures", + "rand_core", +] + +[[package]] +name = "clipboard-win" +version = "5.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "052af7878466feccda12ba7a6a67d019d712f296809559b47c12c8cc196d3a9a" +dependencies = [ + "error-code", +] + +[[package]] +name = "codespan-reporting" +version = "0.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "af491d569909a7e4dee0ad7db7f5341fef5c614d5b8ec8cf765732aba3cff681" +dependencies = [ + "unicode-width", +] + +[[package]] +name = "color" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2ec7c5eb7a16992b1904d76c517d170ab353b0e0b3d5a0c81a8a0cd1037893cf" +dependencies = [ + "bytemuck", +] + +[[package]] +name = "colorchoice" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570" + +[[package]] +name = "combine" +version = "4.6.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4356eba6976435498d05a311ee9fc486da3bc81c200d3f0d7dd9703b41913f92" +dependencies = [ + "bytes", + "memchr", +] + +[[package]] +name = "concurrent-queue" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973" +dependencies = [ + "crossbeam-utils", + "portable-atomic", +] + +[[package]] +name = "console_error_panic_hook" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc" +dependencies = [ + "cfg-if", + "wasm-bindgen", +] + +[[package]] +name = "const-fnv1a-hash" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32b13ea120a812beba79e34316b3942a857c86ec1593cb34f27bb28272ce2cca" + +[[package]] +name = "const_panic" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9603f79528ece8163c496f8932121cb36cfe46259e9c907bb3d8205139d7caa3" +dependencies = [ + "typewit", +] + +[[package]] +name = "const_soft_float" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "87ca1caa64ef4ed453e68bb3db612e51cf1b2f5b871337f0fcab1c8f87cc3dff" + +[[package]] +name = "constant_time_eq" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d52eff69cd5e647efe296129160853a42795992097e8af39800e1060caeea9b" + +[[package]] +name = "constgebra" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1aaf9b65849a68662ac6c0810c8893a765c960b907dd7cfab9c4a50bf764fbc" +dependencies = [ + "const_soft_float", +] + +[[package]] +name = "convert_case" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "633458d4ef8c78b72454de2d54fd6ab2e60f9e02be22f3c6104cdc8a4e0fceb9" +dependencies = [ + "unicode-segmentation", +] + +[[package]] +name = "core-foundation" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "core-foundation-sys" +version = "0.8.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" + +[[package]] +name = "core-graphics" +version = "0.23.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c07782be35f9e1140080c6b96f0d44b739e2278479f64e02fdab4e32dfd8b081" +dependencies = [ + "bitflags 1.3.2", + "core-foundation", + "core-graphics-types", + "foreign-types", + "libc", +] + +[[package]] +name = "core-graphics-types" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "45390e6114f68f718cc7a830514a96f903cccd70d02a8f6d9f643ac4ba45afaf" +dependencies = [ + "bitflags 1.3.2", + "core-foundation", + "libc", +] + +[[package]] +name = "cpufeatures" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5ca28b0ae3115b884660db4118d803791fd6756b6e88f39c0f3f7859060d7566" +dependencies = [ + "libc", +] + +[[package]] +name = "crc32fast" +version = "1.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ba106e844045ddc02c20768ac4b0b7cb45f2cc2ecbd833ac9f5dacb183c2055" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "critical-section" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "790eea4361631c5e7d22598ecd5723ff611904e3344ce8720784c93e3d83d40b" + +[[package]] +name = "crossbeam-channel" +version = "0.5.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "98b0cc327b5bc766e7fda9c9260cc0fa81b43a8e240440422dff70788e3f9ef1" +dependencies = [ + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-deque" +version = "0.8.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "622f3fc73690be383c7214310406f28a90e6edeadc3cea882f9d71e495b9711a" +dependencies = [ + "crossbeam-epoch", + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-epoch" +version = "0.9.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc74980687109a3b14c72fd458107bf0baa1da1a1a805e178d15501ba9b86d9d" +dependencies = [ + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-queue" +version = "0.3.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "03e8bd762f7479489c70ed6c768ddca99d7296857de437a68dcb2a94365b3fae" +dependencies = [ + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-utils" +version = "0.8.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a31eee39dddec8330830986fcd7625edb5a24ec90ea038215273bbc3adb08ac6" + +[[package]] +name = "crunchy" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5" + +[[package]] +name = "ctrlc" +version = "3.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e0b1fab2ae45819af2d0731d60f2afe17227ebb1a1538a236da84c93e9a60162" +dependencies = [ + "dispatch2", + "nix", + "windows-sys 0.61.2", +] + +[[package]] +name = "cursor-icon" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f27ae1dd37df86211c42e150270f82743308803d90a6f6e6651cd730d5e1732f" + +[[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 = [ + "convert_case", + "proc-macro2", + "quote", + "rustc_version", + "syn 2.0.119", + "unicode-xid", +] + +[[package]] +name = "dispatch" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bd0c93bb4b0c6d9b77f4435b0ae98c24d17f1c45b2ff844c6151a07256ca923b" + +[[package]] +name = "dispatch2" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e0e367e4e7da84520dedcac1901e4da967309406d1e51017ae1abfb97adbd38" +dependencies = [ + "bitflags 2.13.2", + "block2 0.6.2", + "libc", + "objc2 0.6.5", +] + +[[package]] +name = "disqualified" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e90a5dd66beeca277ae954f8055b02a712792b6b6b43f2bc2f92b0b7d8291614" + +[[package]] +name = "dlib" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ab8ecd87370524b461f8557c119c405552c396ed91fc0a8eec68679eab26f94a" +dependencies = [ + "libloading", +] + +[[package]] +name = "document-features" +version = "0.2.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d4b8a88685455ed29a21542a33abd9cb6510b6b129abadabdcef0f4c55bc8f61" +dependencies = [ + "litrs", +] + +[[package]] +name = "downcast-rs" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75b325c5dbd37f80359721ad39aca5a29fb04c89279657cffdda8736d0c0b9d2" + +[[package]] +name = "downcast-rs" +version = "2.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "117240f60069e65410b3ae1bb213295bd828f707b5bec6596a1afc8793ce0cbc" + +[[package]] +name = "dpi" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8b14ccef22fc6f5a8f4d7d768562a182c04ce9a3b3157b91390b52ddfdf1a76" + +[[package]] +name = "ecolor" +version = "0.36.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0656a7530b9e2841ee7a5f983965bdd9840c32f4012f759cfd44b912cced6b34" +dependencies = [ + "bytemuck", + "emath", +] + +[[package]] +name = "egui" +version = "0.36.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc938cc27cd911415e1e4d151bc56ff9df063d8db081374e87aeb805ea74b2ba" +dependencies = [ + "accesskit", + "ahash", + "bitflags 2.13.2", + "emath", + "epaint", + "itertools 0.15.0", + "log", + "nohash-hasher", + "profiling", + "smallvec", + "unicode-segmentation", + "web-sys", +] + +[[package]] +name = "either" +version = "1.19.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0e9c71c2167ca323c882b99918929403426e2373ea17242ff5653e0d5e1058be" + +[[package]] +name = "emath" +version = "0.36.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52c8d4141cf0f60fb2f7aefaf352d3ffa5171ef0ab09731c64391801e95e48f1" +dependencies = [ + "bytemuck", +] + +[[package]] +name = "encase" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b1acbc46b960480c4959213714511e22f9a2e0d361520693bcf5057b5924f53e" +dependencies = [ + "const_panic", + "encase_derive", + "thiserror 2.0.21", +] + +[[package]] +name = "encase_derive" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e30d38c47336a0afbdfde297b442944041cf6dccbb1a79eceea16abfb27a92a" +dependencies = [ + "encase_derive_impl", +] + +[[package]] +name = "encase_derive_impl" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "495d24abe406f090f2ba8fc362ecaa8a001e192522aa75eae7b144163c3235ff" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "epaint" +version = "0.36.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a0ec0308dc23130fc1a7d4623a8534c2ed069c6dc84e258ee4f3de99615aa1a3" +dependencies = [ + "ahash", + "bytemuck", + "ecolor", + "emath", + "epaint_default_fonts", + "font-types", + "harfrust", + "log", + "nohash-hasher", + "parking_lot", + "profiling", + "self_cell", + "skrifa", + "smallvec", + "unicode-general-category", + "unicode-segmentation", + "vello_cpu", +] + +[[package]] +name = "epaint_default_fonts" +version = "0.36.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "773fa9c96dd0dbef887e39d0ed6177f141cce4d68e6041df77570aa3702dfa13" + +[[package]] +name = "equivalent" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "00d174d5400e5e8fd687ad1049e2f578285fa914201b1af7e8b112a4546bd826" + +[[package]] +name = "erased-serde" +version = "0.4.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e59b668157f32d3459d4bd634861a06ffa2503a461ca5f0916b9f0252605e66" +dependencies = [ + "serde", + "serde_core", + "typeid", +] + +[[package]] +name = "errno" +version = "0.3.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" +dependencies = [ + "libc", + "windows-sys 0.61.2", +] + +[[package]] +name = "error-code" +version = "3.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b5343afd4a8365a643ac588dab4cf234a190c7f6c88c9f6dd6ffe00837661b7" + +[[package]] +name = "euclid" +version = "0.22.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1a05365e3b1c6d1650318537c7460c6923f1abdd272ad6842baa2b509957a06" +dependencies = [ + "num-traits", +] + +[[package]] +name = "event-listener" +version = "5.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a23add41df1562121a9393cb065eab5146a1242410f23a644851e90cfd669d2" +dependencies = [ + "parking", + "pin-project-lite", +] + +[[package]] +name = "event-listener-strategy" +version = "0.5.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93" +dependencies = [ + "event-listener", + "pin-project-lite", +] + +[[package]] +name = "fastrand" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223" + +[[package]] +name = "fdeflate" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c" +dependencies = [ + "simd-adler32", +] + +[[package]] +name = "fearless_simd" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b97b65636e5b9ef369943878ac74335ba1c55c1cb6adbf1e2c293c624248d693" + +[[package]] +name = "find-msvc-tools" +version = "0.1.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c66915cc5391097de7a2b0b972e8505aa33c0df401fd3a6811dbdb32881ba48" + +[[package]] +name = "fixedbitset" +version = "0.5.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99" + +[[package]] +name = "flate2" +version = "1.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e634e2e0ebac1ee034020da1ca582e17ffe4e0f5e985823721e168928136dcb" +dependencies = [ + "crc32fast", + "miniz_oxide 0.9.1", + "zlib-rs", +] + +[[package]] +name = "fnv" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" + +[[package]] +name = "foldhash" +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 = "font-types" +version = "0.12.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "835ae9d781464a79026cde387f9cbc650c9a4909d7cf7e658b127e3c35d2f35d" +dependencies = [ + "bytemuck", +] + +[[package]] +name = "foreign-types" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d737d9aa519fb7b749cbc3b962edcf310a8dd1f4b67c91c4f83975dbdd17d965" +dependencies = [ + "foreign-types-macros", + "foreign-types-shared", +] + +[[package]] +name = "foreign-types-macros" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea5190182e6915eb873ddbc16e23b711b6eb1f9c00a0d0a3a91b5f6228475225" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.9", +] + +[[package]] +name = "foreign-types-shared" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aa9a19cbb55df58761df49b23516a86d432839add4af60fc256da840f66ed35b" + +[[package]] +name = "futures-channel" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b1f9e3d69d39e4862ffed03ed071a76f9a13ba1d9109d355b0f0aa6b15e393c4" +dependencies = [ + "futures-core", +] + +[[package]] +name = "futures-core" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "92d699e522242e69e3003b94ecc1f960f3a5e015aa7c5d7486e65ad01dd94f5e" + +[[package]] +name = "futures-io" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "53c0fa8157de1303bfffdaa1cc2a673bfffb60102f76b0ef4441659124373fed" + +[[package]] +name = "futures-lite" +version = "2.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f78e10609fe0e0b3f4157ffab1876319b5b0db102a2c60dc4626306dc46b44ad" +dependencies = [ + "fastrand", + "futures-core", + "futures-io", + "parking", + "pin-project-lite", +] + +[[package]] +name = "futures-macro" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9fb9654ba8355388abeb8dcb4fc62f511300867002afc858860463bdd9fe0c44" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.9", +] + +[[package]] +name = "futures-task" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cd417de3d1d015fc3bfd2b1ea46dfc7bab72ef86f1cc7cc9c78e728b34a6d1fd" + +[[package]] +name = "futures-util" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d50a92467f8ba5dd6e3ee5d4bd04d73ab2e4e1c44474a0674821dfce14b79bc" +dependencies = [ + "futures-core", + "futures-macro", + "futures-task", + "pin-project-lite", + "slab", +] + +[[package]] +name = "gethostname" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1bd49230192a3797a9a4d6abe9b3eed6f7fa4c8a8a4947977c6f80025f92cbd8" +dependencies = [ + "rustix 1.1.5", + "windows-link", +] + +[[package]] +name = "getrandom" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0" +dependencies = [ + "cfg-if", + "libc", + "wasi", +] + +[[package]] +name = "getrandom" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd" +dependencies = [ + "cfg-if", + "libc", + "r-efi 5.3.0", + "wasip2", +] + +[[package]] +name = "getrandom" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099" +dependencies = [ + "cfg-if", + "js-sys", + "libc", + "r-efi 6.0.0", + "rand_core", + "wasm-bindgen", +] + +[[package]] +name = "glam" +version = "0.33.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37bfe73dc8ec21f54d181e5a60554327ec3f1c600c455a75ccbfc65d2106a6c4" +dependencies = [ + "approx", + "bytemuck", + "encase", + "libm", + "rand", + "serde_core", +] + +[[package]] +name = "glifo" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed4a1bb24121291d27230c1b1b44e07d6a9b28cefdb32fe1581dfb84e14f940a" +dependencies = [ + "bytemuck", + "foldhash 0.2.0", + "hashbrown 0.17.1", + "log", + "peniko", + "skrifa", + "smallvec", + "vello_common", +] + +[[package]] +name = "glob" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e4eba85ea1d0a966a983acd07deee566e67395d2d96b6fb39e62b5a833f1eb0b" + +[[package]] +name = "gpu-allocator" +version = "0.28.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "51255ea7cfaadb6c5f1528d43e92a82acb2b96c43365989a28b2d44ee38f8795" +dependencies = [ + "ash", + "hashbrown 0.16.1", + "log", + "presser", + "thiserror 2.0.21", + "windows", +] + +[[package]] +name = "guillotiere" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6b17e70c989c36bad147b27a58d148c0741c51448aa5653436547323e524d0ab" +dependencies = [ + "euclid", +] + +[[package]] +name = "half" +version = "2.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b" +dependencies = [ + "bytemuck", + "cfg-if", + "crunchy", + "num-traits", + "zerocopy", +] + +[[package]] +name = "harfrust" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c03d949a14aa089bbb282f7dd76a498a7f684428e4257202efc119ec010376f9" +dependencies = [ + "bitflags 2.13.2", + "bytemuck", + "read-fonts", + "smallvec", +] + +[[package]] +name = "hash32" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "47d60b12902ba28e2730cd37e95b8c9223af2808df9e902d4df49588d1470606" +dependencies = [ + "byteorder", +] + +[[package]] +name = "hashbrown" +version = "0.15.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1" +dependencies = [ + "foldhash 0.1.5", +] + +[[package]] +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", + "serde", + "serde_core", +] + +[[package]] +name = "hashbrown" +version = "0.17.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a" +dependencies = [ + "foldhash 0.2.0", +] + +[[package]] +name = "heapless" +version = "0.9.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "25ba4bd83f9415b58b4ed8dc5714c76e626a105be4646c02630ad730ad3b5aa4" +dependencies = [ + "hash32", + "portable-atomic", + "stable_deref_trait", +] + +[[package]] +name = "hermit-abi" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e17592d60ebacc7d5e169f4663c5f84f9161cc90328abcfe8456f41e4dfcb284" + +[[package]] +name = "hexasphere" +version = "19.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "163385eff5a0cf606ebe2c10b3a44ab02f4306e83fbd068a64f5e1d72a3049ac" +dependencies = [ + "constgebra", + "glam", + "tinyvec", +] + +[[package]] +name = "http" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "918d3568bebf352712bc2ef3d46a8bcf1a75b373be6539de198e9105cbbf9ce0" +dependencies = [ + "bytes", + "itoa", +] + +[[package]] +name = "httparse" +version = "1.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87" + +[[package]] +name = "image" +version = "0.25.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85ab80394333c02fe689eaf900ab500fbd0c2213da414687ebf995a65d5a6104" +dependencies = [ + "bytemuck", + "byteorder-lite", + "moxcms", + "num-traits", + "png", +] + +[[package]] +name = "indexmap" +version = "2.14.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855" +dependencies = [ + "equivalent", + "hashbrown 0.17.1", + "serde", + "serde_core", +] + +[[package]] +name = "inventory" +version = "0.3.25" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6928282826c822ad91bf1c9a1cb90a30ba1c26770749929b4656cd6be829cd7c" +dependencies = [ + "rustversion", +] + +[[package]] +name = "is_terminal_polyfill" +version = "1.70.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695" + +[[package]] +name = "itertools" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285" +dependencies = [ + "either", +] + +[[package]] +name = "itertools" +version = "0.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b4baf93f58d4425749ca49a51c50ebab072c5df6994d08fed93541c331481dc" +dependencies = [ + "either", +] + +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + +[[package]] +name = "jni" +version = "0.22.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5efd9a482cf3a427f00d6b35f14332adc7902ce91efb778580e180ff90fa3498" +dependencies = [ + "cfg-if", + "combine", + "jni-macros", + "jni-sys 0.4.1", + "log", + "simd_cesu8", + "thiserror 2.0.21", + "walkdir", + "windows-link", +] + +[[package]] +name = "jni-macros" +version = "0.22.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a00109accc170f0bdb141fed3e393c565b6f5e072365c3bd58f5b062591560a3" +dependencies = [ + "proc-macro2", + "quote", + "rustc_version", + "simd_cesu8", + "syn 2.0.119", +] + +[[package]] +name = "jni-sys" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41a652e1f9b6e0275df1f15b32661cf0d4b78d4d87ddec5e0c3c20f097433258" +dependencies = [ + "jni-sys 0.4.1", +] + +[[package]] +name = "jni-sys" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6377a88cb3910bee9b0fa88d4f42e1d2da8e79915598f65fb0c7ee14c878af2" +dependencies = [ + "jni-sys-macros", +] + +[[package]] +name = "jni-sys-macros" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38c0b942f458fe50cdac086d2f946512305e5631e720728f2a61aabcd47a6264" +dependencies = [ + "quote", + "syn 2.0.119", +] + +[[package]] +name = "jobserver" +version = "0.1.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c00acbd29eabad4a2392fa0e921c874934dbbf4194312ad20f04a0ed67a3cb3" +dependencies = [ + "getrandom 0.4.3", + "libc", +] + +[[package]] +name = "js-sys" +version = "0.3.106" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7883d941dae510fb2d978fc3fe018c71c9e2892fd38854de3e8b92c2e5ad9cc5" +dependencies = [ + "cfg-if", + "futures-util", + "wasm-bindgen", +] + +[[package]] +name = "kurbo" +version = "0.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b60dfc32f652b926df6192e55525b16d186c69d47876c3ead4da5cc9f8450e2" +dependencies = [ + "arrayvec", + "euclid", + "polycool", + "smallvec", +] + +[[package]] +name = "lalrpop-util" +version = "0.23.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "364b49d1c98c07972e16fe1346463becc08bcd663da04e6e37ab1bea068dce6a" +dependencies = [ + "regex-automata", +] + +[[package]] +name = "lazy_static" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "20870f649af7073d53e38067b2a84312175d56ea15217e1b15bc83506ec50afb" + +[[package]] +name = "lexical" +version = "7.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1bc8a009b2ff1f419ccc62706f04fe0ca6e67b37460513964a3dfdb919bb37d6" +dependencies = [ + "lexical-core", +] + +[[package]] +name = "lexical-core" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d8d125a277f807e55a77304455eb7b1cb52f2b18c143b60e766c120bd64a594" +dependencies = [ + "lexical-parse-float", + "lexical-parse-integer", + "lexical-util", + "lexical-write-float", + "lexical-write-integer", +] + +[[package]] +name = "lexical-parse-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52a9f232fbd6f550bc0137dcb5f99ab674071ac2d690ac69704593cb4abbea56" +dependencies = [ + "lexical-parse-integer", + "lexical-util", +] + +[[package]] +name = "lexical-parse-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a7a039f8fb9c19c996cd7b2fcce303c1b2874fe1aca544edc85c4a5f8489b34" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "lexical-util" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2604dd126bb14f13fb5d1bd6a66155079cb9fa655b37f875b3a742c705dbed17" + +[[package]] +name = "lexical-write-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50c438c87c013188d415fbabbb1dceb44249ab81664efbd31b14ae55dabb6361" +dependencies = [ + "lexical-util", + "lexical-write-integer", +] + +[[package]] +name = "lexical-write-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "409851a618475d2d5796377cad353802345cba92c867d9fbcde9cf4eac4e14df" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "libc" +version = "0.2.191" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65cd87c9a6d60536580b316ad985726104730a5151c99845f2490428ef91240a" + +[[package]] +name = "libloading" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55" +dependencies = [ + "cfg-if", + "windows-link", +] + +[[package]] +name = "libm" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981" + +[[package]] +name = "libredox" +version = "0.1.25" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "61ff90caf6077a803a240f62fdbe88645a890bbca49ef8174c3cb0404362171d" +dependencies = [ + "bitflags 2.13.2", + "libc", + "plain", + "redox_syscall 0.9.5", +] + +[[package]] +name = "linebender_resource_handle" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d4a5ff6bcca6c4867b1c4fd4ef63e4db7436ef363e0ad7531d1558856bae64f4" + +[[package]] +name = "linux-raw-sys" +version = "0.4.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab" + +[[package]] +name = "linux-raw-sys" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53" + +[[package]] +name = "litrs" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4744e383959f0db86ede514b809b1c53251889093803c05267acc7d4e7030d70" + +[[package]] +name = "lock_api" +version = "0.4.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965" +dependencies = [ + "scopeguard", +] + +[[package]] +name = "log" +version = "0.4.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6" + +[[package]] +name = "logos" +version = "0.16.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eb2c55a318a87600ea870ff8c2012148b44bf18b74fad48d0f835c38c7d07c5f" +dependencies = [ + "logos-derive", +] + +[[package]] +name = "logos-codegen" +version = "0.16.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "58b3ffaa284e1350d017a57d04ada118c4583cf260c8fb01e0fe28a2e9cf8970" +dependencies = [ + "fnv", + "proc-macro2", + "quote", + "regex-automata", + "regex-syntax", + "syn 2.0.119", +] + +[[package]] +name = "logos-derive" +version = "0.16.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52d3a9855747c17eaf4383823f135220716ab49bea5fbea7dd42cc9a92f8aa31" +dependencies = [ + "logos-codegen", +] + +[[package]] +name = "matchers" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d1525a2a28c7f4fa0fc98bb91ae755d1e2d1505079e05539e35bc876b5d65ae9" +dependencies = [ + "regex-automata", +] + +[[package]] +name = "matrixmultiply" +version = "0.3.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f607c237553f086e7043417a51df26b2eb899d3caff94e6a67592ff992fedc7" +dependencies = [ + "autocfg", + "rawpointer", +] + +[[package]] +name = "memchr" +version = "2.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" + +[[package]] +name = "memmap2" +version = "0.9.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6b0ca1155a9ecc25aa12e8313a119f32edf0255fea2f44839c4ac0a12b2ac157" +dependencies = [ + "libc", +] + +[[package]] +name = "miniz_oxide" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316" +dependencies = [ + "adler2", + "simd-adler32", +] + +[[package]] +name = "miniz_oxide" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b63fbc4a50860e98e7b2aa7804ded1db5cbc3aff9193adaff57a6931bf7c4b4c" +dependencies = [ + "adler2", + "simd-adler32", +] + +[[package]] +name = "moxcms" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bb85c154ba489f01b25c0d36ae69a87e4a1c73a72631fc6c0eb6dde34a73e44b" +dependencies = [ + "num-traits", + "pxfm", +] + +[[package]] +name = "mutants" +version = "0.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bc0287524726960e07b119cebd01678f852f147742ae0d925e6a520dca956126" + +[[package]] +name = "naga" +version = "30.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a616d2fb8c89516ac2723a581f69d6c18576046bed761bd6b305e5618e6ae130" +dependencies = [ + "arrayvec", + "bit-set", + "bitflags 2.13.2", + "cfg-if", + "cfg_aliases", + "codespan-reporting", + "half", + "hashbrown 0.17.1", + "indexmap", + "libm", + "log", + "naga-types", + "num-traits", + "once_cell", + "rustc-hash 1.1.0", + "spirv", + "thiserror 2.0.21", + "unicode-ident", +] + +[[package]] +name = "naga-types" +version = "30.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "590afbf58a6f4f62873cd5cff4468061844bafa1cdf399cc954537c22d768d49" +dependencies = [ + "hashbrown 0.17.1", + "indexmap", + "rustc-hash 1.1.0", + "serde", + "thiserror 2.0.21", +] + +[[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", + "rayon", +] + +[[package]] +name = "ndk" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3f42e7bbe13d351b6bead8286a43aac9534b82bd3cc43e47037f012ebfd62d4" +dependencies = [ + "bitflags 2.13.2", + "jni-sys 0.3.1", + "log", + "ndk-sys", + "num_enum", + "raw-window-handle", + "thiserror 1.0.69", +] + +[[package]] +name = "ndk-context" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "27b02d87554356db9e9a873add8782d4ea6e3e58ea071a9adb9a2e8ddb884a8b" + +[[package]] +name = "ndk-sys" +version = "0.6.0+11769913" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee6cda3051665f1fb8d9e08fc35c96d5a244fb1be711a03b71118828afc9a873" +dependencies = [ + "jni-sys 0.3.1", +] + +[[package]] +name = "nix" +version = "0.31.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf20d2fde8ff38632c426f1165ed7436270b44f199fc55284c38276f9db47c3d" +dependencies = [ + "bitflags 2.13.2", + "cfg-if", + "cfg_aliases", + "libc", +] + +[[package]] +name = "nohash-hasher" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2bf50223579dc7cdcfb3bfcacf7069ff68243f8c363f62ffa99cf000a6b9c451" + +[[package]] +name = "nom" +version = "8.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df9761775871bdef83bee530e60050f7e54b1105350d6884eb0fb4f46c2f9405" +dependencies = [ + "memchr", +] + +[[package]] +name = "nonmax" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "610a5acd306ec67f907abe5567859a3c693fb9886eb1f012ab8f2a47bef3db51" + +[[package]] +name = "nu-ansi-term" +version = "0.50.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5" +dependencies = [ + "windows-sys 0.61.2", +] + +[[package]] +name = "num-complex" +version = "0.4.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495" +dependencies = [ + "num-traits", +] + +[[package]] +name = "num-integer" +version = "0.1.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7ce2d95d4b3734dc35aa2f45e1aa22cd416814592a4f9d9205e11affd5b8e10b" +dependencies = [ + "num-traits", +] + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", + "libm", +] + +[[package]] +name = "num_enum" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d0bca838442ec211fa11de3a8b0e0e8f3a4522575b5c4c06ed722e005036f26" +dependencies = [ + "num_enum_derive", + "rustversion", +] + +[[package]] +name = "num_enum_derive" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "680998035259dcfcafe653688bf2aa6d3e2dc05e98be6ab46afb089dc84f1df8" +dependencies = [ + "proc-macro-crate", + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "objc-sys" +version = "0.3.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cdb91bdd390c7ce1a8607f35f3ca7151b65afc0ff5ff3b34fa350f7d7c7e4310" + +[[package]] +name = "objc2" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19d5490aaf8f1d7cf7688dfa9b0ce07900e168852c45cd2c03f534dfd27cfd0b" +dependencies = [ + "objc-sys", + "objc2-encode", +] + +[[package]] +name = "objc2" +version = "0.6.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08849bbd4767dfae9457696856ae1c84fe4e0281bbe4a7abff2d0e06fb7981f8" +dependencies = [ + "objc2-encode", +] + +[[package]] +name = "objc2-app-kit" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e4e89ad9e3d7d297152b17d39ed92cd50ca8063a89a9fa569046d41568891eff" +dependencies = [ + "bitflags 2.13.2", + "block2 0.5.1", + "libc", + "objc2 0.5.3", + "objc2-core-data", + "objc2-core-image", + "objc2-foundation 0.2.2", + "objc2-quartz-core 0.2.2", +] + +[[package]] +name = "objc2-app-kit" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d49e936b501e5c5bf01fda3a9452ff86dc3ea98ad5f283e1455153142d97518c" +dependencies = [ + "bitflags 2.13.2", + "objc2 0.6.5", + "objc2-core-graphics", + "objc2-foundation 0.3.2", +] + +[[package]] +name = "objc2-cloud-kit" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "74dd3b56391c7a0596a295029734d3c1c5e7e510a4cb30245f8221ccea96b009" +dependencies = [ + "bitflags 2.13.2", + "block2 0.5.1", + "objc2 0.5.3", + "objc2-core-location", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "objc2-contacts" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a5ff520e9c33812fd374d8deecef01d4a840e7b41862d849513de77e44aa4889" +dependencies = [ + "block2 0.5.1", + "objc2 0.5.3", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "objc2-core-data" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "617fbf49e071c178c0b24c080767db52958f716d9eabdf0890523aeae54773ef" +dependencies = [ + "bitflags 2.13.2", + "block2 0.5.1", + "objc2 0.5.3", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "objc2-core-foundation" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536" +dependencies = [ + "bitflags 2.13.2", + "dispatch2", + "objc2 0.6.5", +] + +[[package]] +name = "objc2-core-graphics" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e022c9d066895efa1345f8e33e584b9f958da2fd4cd116792e15e07e4720a807" +dependencies = [ + "bitflags 2.13.2", + "dispatch2", + "objc2 0.6.5", + "objc2-core-foundation", + "objc2-io-surface", +] + +[[package]] +name = "objc2-core-image" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "55260963a527c99f1819c4f8e3b47fe04f9650694ef348ffd2227e8196d34c80" +dependencies = [ + "block2 0.5.1", + "objc2 0.5.3", + "objc2-foundation 0.2.2", + "objc2-metal 0.2.2", +] + +[[package]] +name = "objc2-core-location" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "000cfee34e683244f284252ee206a27953279d370e309649dc3ee317b37e5781" +dependencies = [ + "block2 0.5.1", + "objc2 0.5.3", + "objc2-contacts", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "objc2-encode" +version = "4.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33" + +[[package]] +name = "objc2-foundation" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ee638a5da3799329310ad4cfa62fbf045d5f56e3ef5ba4149e7452dcf89d5a8" +dependencies = [ + "bitflags 2.13.2", + "block2 0.5.1", + "dispatch", + "libc", + "objc2 0.5.3", +] + +[[package]] +name = "objc2-foundation" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3e0adef53c21f888deb4fa59fc59f7eb17404926ee8a6f59f5df0fd7f9f3272" +dependencies = [ + "bitflags 2.13.2", + "objc2 0.6.5", + "objc2-core-foundation", +] + +[[package]] +name = "objc2-io-surface" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "180788110936d59bab6bd83b6060ffdfffb3b922ba1396b312ae795e1de9d81d" +dependencies = [ + "bitflags 2.13.2", + "objc2 0.6.5", + "objc2-core-foundation", +] + +[[package]] +name = "objc2-link-presentation" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a1a1ae721c5e35be65f01a03b6d2ac13a54cb4fa70d8a5da293d7b0020261398" +dependencies = [ + "block2 0.5.1", + "objc2 0.5.3", + "objc2-app-kit 0.2.2", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "objc2-metal" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dd0cba1276f6023976a406a14ffa85e1fdd19df6b0f737b063b95f6c8c7aadd6" +dependencies = [ + "bitflags 2.13.2", + "block2 0.5.1", + "objc2 0.5.3", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "objc2-metal" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a0125f776a10d00af4152d74616409f0d4a2053a6f57fa5b7d6aa2854ac04794" +dependencies = [ + "bitflags 2.13.2", + "block2 0.6.2", + "objc2 0.6.5", + "objc2-foundation 0.3.2", +] + +[[package]] +name = "objc2-quartz-core" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e42bee7bff906b14b167da2bac5efe6b6a07e6f7c0a21a7308d40c960242dc7a" +dependencies = [ + "bitflags 2.13.2", + "block2 0.5.1", + "objc2 0.5.3", + "objc2-foundation 0.2.2", + "objc2-metal 0.2.2", +] + +[[package]] +name = "objc2-quartz-core" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96c1358452b371bf9f104e21ec536d37a650eb10f7ee379fff67d2e08d537f1f" +dependencies = [ + "bitflags 2.13.2", + "objc2 0.6.5", + "objc2-core-foundation", + "objc2-core-graphics", + "objc2-foundation 0.3.2", + "objc2-metal 0.3.2", +] + +[[package]] +name = "objc2-symbols" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0a684efe3dec1b305badae1a28f6555f6ddd3bb2c2267896782858d5a78404dc" +dependencies = [ + "objc2 0.5.3", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "objc2-ui-kit" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8bb46798b20cd6b91cbd113524c490f1686f4c4e8f49502431415f3512e2b6f" +dependencies = [ + "bitflags 2.13.2", + "block2 0.5.1", + "objc2 0.5.3", + "objc2-cloud-kit", + "objc2-core-data", + "objc2-core-image", + "objc2-core-location", + "objc2-foundation 0.2.2", + "objc2-link-presentation", + "objc2-quartz-core 0.2.2", + "objc2-symbols", + "objc2-uniform-type-identifiers", + "objc2-user-notifications", +] + +[[package]] +name = "objc2-uniform-type-identifiers" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "44fa5f9748dbfe1ca6c0b79ad20725a11eca7c2218bceb4b005cb1be26273bfe" +dependencies = [ + "block2 0.5.1", + "objc2 0.5.3", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "objc2-user-notifications" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76cfcbf642358e8689af64cee815d139339f3ed8ad05103ed5eaf73db8d84cb3" +dependencies = [ + "bitflags 2.13.2", + "block2 0.5.1", + "objc2 0.5.3", + "objc2-core-location", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "offset-allocator" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e234d535da3521eb95106f40f0b73483d80bfb3aacf27c40d7e2b72f1a3e00a2" +dependencies = [ + "log", + "nonmax", +] + +[[package]] +name = "once_cell" +version = "1.21.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50" + +[[package]] +name = "once_cell_polyfill" +version = "1.70.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe" + +[[package]] +name = "orbclient" +version = "0.3.55" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5df339f526ea9a60e371768d50efc2f2508c7203290731565d1f7a6f71d21747" +dependencies = [ + "libc", + "libredox", +] + +[[package]] +name = "ordered-float" +version = "5.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f59006ce1e204c30956638535b74d317bca99477b9356dfaec54c37f6f600ab" +dependencies = [ + "num-traits", +] + +[[package]] +name = "os_pipe" +version = "1.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967" +dependencies = [ + "libc", + "windows-sys 0.61.2", +] + +[[package]] +name = "owned_ttf_parser" +version = "0.25.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "36820e9051aca1014ddc75770aab4d68bc1e9e632f0f5627c4086bc216fb583b" +dependencies = [ + "ttf-parser", +] + +[[package]] +name = "parking" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba" + +[[package]] +name = "parking_lot" +version = "0.12.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a" +dependencies = [ + "lock_api", + "parking_lot_core", +] + +[[package]] +name = "parking_lot_core" +version = "0.9.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1" +dependencies = [ + "cfg-if", + "libc", + "redox_syscall 0.5.18", + "smallvec", + "windows-link", +] + +[[package]] +name = "peniko" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "839c8299360d2e998bdb106dc0a6cd71dcc5f4df51df1b620361bf50e283cca6" +dependencies = [ + "bytemuck", + "color", + "kurbo", + "linebender_resource_handle", + "smallvec", +] + +[[package]] +name = "percent-encoding" +version = "2.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220" + +[[package]] +name = "petgraph" +version = "0.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8701b58ea97060d5e5b155d383a69952a60943f0e6dfe30b04c287beb0b27455" +dependencies = [ + "fixedbitset", + "hashbrown 0.15.5", + "indexmap", +] + +[[package]] +name = "pin-project" +version = "1.1.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2466b2336ed02bcdca6b294417127b90ec92038d1d5c4fbeac971a922e0e0924" +dependencies = [ + "pin-project-internal", +] + +[[package]] +name = "pin-project-internal" +version = "1.1.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c96395f0a926bc13b1c17622aaddda1ecb55d49c8f1bf9777e4d877800a43f8b" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "pin-project-lite" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd" + +[[package]] +name = "piper" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c835479a4443ded371d6c535cbfd8d31ad92c5d23ae9770a61bc155e4992a3c1" +dependencies = [ + "atomic-waker", + "fastrand", + "futures-io", +] + +[[package]] +name = "pkg-config" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f6b464fbc74e149a392436b17d523f769e057cb6877f6a5c4618bc6f11800548" + +[[package]] +name = "plain" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6" + +[[package]] +name = "png" +version = "0.18.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "60769b8b31b2a9f263dae2776c37b1b28ae246943cf719eb6946a1db05128a61" +dependencies = [ + "bitflags 2.13.2", + "crc32fast", + "fdeflate", + "flate2", + "miniz_oxide 0.8.9", +] + +[[package]] +name = "polling" +version = "3.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d0e4f59085d47d8241c88ead0f274e8a0cb551f3625263c05eb8dd897c34218" +dependencies = [ + "cfg-if", + "concurrent-queue", + "hermit-abi", + "pin-project-lite", + "rustix 1.1.5", + "windows-sys 0.61.2", +] + +[[package]] +name = "polycool" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50596ddc09eb5ad5f75cacd40209568e66df71baf86e1499a0e99c4cff12a5a6" +dependencies = [ + "arrayvec", +] + +[[package]] +name = "portable-atomic" +version = "1.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85" + +[[package]] +name = "portable-atomic-util" +version = "0.2.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "10ab3eb7f3becc3a1cbc4f2c6f20267996cfc1a6467a873763411b136a122715" +dependencies = [ + "portable-atomic", +] + +[[package]] +name = "presser" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e8cf8e6a8aa66ce33f63993ffc4ea4271eb5b0530a9002db8455ea6050c77bfa" + +[[package]] +name = "proc-macro-crate" +version = "3.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f" +dependencies = [ + "toml_edit", +] + +[[package]] +name = "proc-macro2" +version = "1.0.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "profiling" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d595e54a326bc53c1c197b32d295e14b169e3cfeaa8dc82b529f947fba6bcf5" + +[[package]] +name = "pxfm" +version = "0.1.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d55d956fa96f5ec02be2e13af0e20391a5aa83d6a074e3ad368959d0fab299ea" + +[[package]] +name = "quick-xml" +version = "0.41.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e660451e55124f798a69a5af3f49ccfbefbd41910eefd25caf2393e1f3473ec1" +dependencies = [ + "memchr", +] + +[[package]] +name = "quote" +version = "1.0.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "r-efi" +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 = "rand" +version = "0.10.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65c9fb96cbc91e3478eaae79a69fcd3f1ae4ad052e471fe6732fff548984b4af" +dependencies = [ + "chacha20", + "getrandom 0.4.3", + "rand_core", +] + +[[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.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4d431c2703ccf129de4d45253c03f49ebb22b97d6ad79ee3ecfc7e3f4862c1d8" +dependencies = [ + "num-traits", + "rand", +] + +[[package]] +name = "range-alloc" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ca45419789ae5a7899559e9512e58ca889e41f04f1f2445e9f4b290ceccd1d08" + +[[package]] +name = "raw-window-handle" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "20675572f6f24e9e76ef639bc5552774ed45f1c30e2951e1e99c59888861c539" + +[[package]] +name = "raw-window-metal" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "40d213455a5f1dc59214213c7330e074ddf8114c9a42411eb890c767357ce135" +dependencies = [ + "objc2 0.6.5", + "objc2-core-foundation", + "objc2-foundation 0.3.2", + "objc2-quartz-core 0.3.2", +] + +[[package]] +name = "rawpointer" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3" + +[[package]] +name = "rayon" +version = "1.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d" +dependencies = [ + "either", + "rayon-core", +] + +[[package]] +name = "rayon-core" +version = "1.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91" +dependencies = [ + "crossbeam-deque", + "crossbeam-utils", +] + +[[package]] +name = "read-fonts" +version = "0.41.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "046a7d674daf459825b32f5062056d6882db0d2f5a479fbd76ccfc870ac18709" +dependencies = [ + "bytemuck", + "font-types", + "once_cell", +] + +[[package]] +name = "rectangle-pack" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a0d463f2884048e7153449a55166f91028d5b0ea53c79377099ce4e8cf0cf9bb" + +[[package]] +name = "redox_syscall" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa" +dependencies = [ + "bitflags 1.3.2", +] + +[[package]] +name = "redox_syscall" +version = "0.5.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d" +dependencies = [ + "bitflags 2.13.2", +] + +[[package]] +name = "redox_syscall" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "580c875845b41ecb1564ad1ae4703044cef774145e3d7a94dc2b3fa7c97868fd" +dependencies = [ + "bitflags 2.13.2", +] + +[[package]] +name = "regex-automata" +version = "0.4.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4" + +[[package]] +name = "renderdoc-sys" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19b30a45b0cd0bcca8037f3d0dc3421eaf95327a17cad11964fb8179b4fc4832" + +[[package]] +name = "ring" +version = "0.17.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7" +dependencies = [ + "cc", + "cfg-if", + "getrandom 0.2.17", + "libc", + "untrusted", + "windows-sys 0.52.0", +] + +[[package]] +name = "ron" +version = "0.12.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "81116b9531d61eabc41aeb228e4b6b2435bcca3233b98cf3b3077d4e6e9debb3" +dependencies = [ + "bitflags 2.13.2", + "once_cell", + "serde", + "serde_derive", + "typeid", + "unicode-ident", +] + +[[package]] +name = "rustc-hash" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2" + +[[package]] +name = "rustc-hash" +version = "2.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d" + +[[package]] +name = "rustc_version" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92" +dependencies = [ + "semver", +] + +[[package]] +name = "rustix" +version = "0.38.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154" +dependencies = [ + "bitflags 2.13.2", + "errno", + "libc", + "linux-raw-sys 0.4.15", + "windows-sys 0.59.0", +] + +[[package]] +name = "rustix" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "891efababe418670775f199f0d233d84843c227a0949a883ce15b37c78d6629d" +dependencies = [ + "bitflags 2.13.2", + "errno", + "libc", + "linux-raw-sys 0.12.1", + "windows-sys 0.61.2", +] + +[[package]] +name = "rustls" +version = "0.23.46" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "48e13bd8c0e9365c43cfa5c9e8f9ad49d3c8444926c9aac819e0e4dc503c8fdf" +dependencies = [ + "log", + "once_cell", + "ring", + "rustls-pki-types", + "rustls-webpki", + "subtle", + "zeroize", +] + +[[package]] +name = "rustls-pki-types" +version = "1.15.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2f4925028c7eb5d1fcdaf196971378ed9d2c1c4efc7dc5d011256f76c99c0a96" +dependencies = [ + "zeroize", +] + +[[package]] +name = "rustls-webpki" +version = "0.103.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4443b1b6d39d7c663139942cc4558262562d2c84123bb6282ef177009ca8b281" +dependencies = [ + "ring", + "rustls-pki-types", + "untrusted", +] + +[[package]] +name = "rustversion" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f" + +[[package]] +name = "ruzstd" +version = "0.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7c1c839d570d835527c9a5e4db7cb2198683a988cb9d7293fc8674e6bd58fc8" +dependencies = [ + "twox-hash", +] + +[[package]] +name = "same-file" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" +dependencies = [ + "winapi-util", +] + +[[package]] +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 = "sctk-adwaita" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6277f0217056f77f1d8f49f2950ac6c278c0d607c45f5ee99328d792ede24ec" +dependencies = [ + "ab_glyph", + "log", + "memmap2", + "smithay-client-toolkit", + "tiny-skia", +] + +[[package]] +name = "self_cell" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2ab42ca02749e120097e328d91d415325bdf43b1c72c4c8badf37375fe40a813" + +[[package]] +name = "semver" +version = "1.0.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd" + +[[package]] +name = "send_wrapper" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cd0b0ec5f1c1ca621c432a25813d8d60c88abe6d3e08a3eb9cf37d97a0fe3d73" + +[[package]] +name = "serde" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.9", +] + +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "serde_spanned" +version = "1.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4e7523beb55eece201a2356bee0bbca0d1ab466c14c07703b2e0ee6d42cb0c2c" +dependencies = [ + "serde_core", +] + +[[package]] +name = "sharded-slab" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6" +dependencies = [ + "lazy_static", +] + +[[package]] +name = "shlex" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba" + +[[package]] +name = "simd-adler32" +version = "0.3.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a219298ac11a56ea9a6d2120044824d6f01aeb034955e7af7bc16858527deea" + +[[package]] +name = "simd_cesu8" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "11031e251abf8611c80f460e19dbdeb54a66db918e49c65a7065b46ac7aec520" +dependencies = [ + "rustc_version", + "simdutf8", +] + +[[package]] +name = "simdutf8" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e" + +[[package]] +name = "skrifa" +version = "0.44.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "819ab7d62b1d3e72d9d9dea5650bac30424f9111364bb94928dbf5ecad1baa68" +dependencies = [ + "bytemuck", + "read-fonts", +] + +[[package]] +name = "slab" +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 = "bdd58c3c93c3d278ca835519292445cb4b0d4dc59ccfdf7ceadaab3f8aeb4038" +dependencies = [ + "version_check", +] + +[[package]] +name = "smallvec" +version = "1.16.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d0d5d4b1981b8bbbb7aed204cae5726d683d5d6ac7e74ec54122ea28f315e7c8" + +[[package]] +name = "smithay-client-toolkit" +version = "0.19.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3457dea1f0eb631b4034d61d4d8c32074caa6cd1ab2d59f2327bd8461e2c0016" +dependencies = [ + "bitflags 2.13.2", + "calloop", + "calloop-wayland-source", + "cursor-icon", + "libc", + "log", + "memmap2", + "rustix 0.38.44", + "thiserror 1.0.69", + "wayland-backend", + "wayland-client", + "wayland-csd-frame", + "wayland-cursor", + "wayland-protocols", + "wayland-protocols-wlr", + "wayland-scanner", + "xkeysym", +] + +[[package]] +name = "smol_str" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dd538fb6910ac1099850255cf94a94df6551fbdd602454387d0adb2d1ca6dead" +dependencies = [ + "serde", +] + +[[package]] +name = "spin" +version = "0.12.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0134f9043ed38b087ac4f7d4af44c79e2c9e5094421fe3164f435ce585953b10" +dependencies = [ + "portable-atomic", +] + +[[package]] +name = "spirv" +version = "0.4.0+sdk-1.4.341.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9571ea910ebd84c86af4b3ed27f9dbdc6ad06f17c5f96146b2b671e2976744f" +dependencies = [ + "bitflags 2.13.2", +] + +[[package]] +name = "stable_deref_trait" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596" + +[[package]] +name = "stackfuture" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "115beb9c69db2393ff10b75a1b8587a51716e5551d015001e55320ed279d32f9" +dependencies = [ + "const_panic", +] + +[[package]] +name = "static_assertions" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f" + +[[package]] +name = "strict-num" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6637bab7722d379c8b41ba849228d680cc12d0a45ba1fa2b48f2a30577a06731" + +[[package]] +name = "subtle" +version = "2.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292" + +[[package]] +name = "syn" +version = "2.0.119" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "syn" +version = "3.0.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d78c8dee4c7bf0e14673097256fed6142ce9d3b85a408189d07482442145823b" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "thiserror" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52" +dependencies = [ + "thiserror-impl 1.0.69", +] + +[[package]] +name = "thiserror" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e" +dependencies = [ + "thiserror-impl 2.0.21", +] + +[[package]] +name = "thiserror-impl" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.9", +] + +[[package]] +name = "thread_local" +version = "1.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ad99c4c6d32803332c548b1af0540b357b3f5fc0be8f6c6bfe8b2e6ae784070" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "tiny-skia" +version = "0.11.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "83d13394d44dae3207b52a326c0c85a8bf87f1541f23b0d143811088497b09ab" +dependencies = [ + "arrayref", + "arrayvec", + "bytemuck", + "cfg-if", + "log", + "tiny-skia-path", +] + +[[package]] +name = "tiny-skia-path" +version = "0.11.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c9e7fc0c2e86a30b117d0462aa261b72b7a99b7ebd7deb3a14ceda95c5bdc93" +dependencies = [ + "arrayref", + "bytemuck", + "strict-num", +] + +[[package]] +name = "tinyvec" +version = "1.13.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fd3ca314f692efd6c868f8408f53fe444634a845f96c028b97d35f6a1f79f0ee" + +[[package]] +name = "tokio" +version = "1.54.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b52fd3255258d26fac7264ab5a76b53c13367136dc011d3d6ad4f8ed070396a3" +dependencies = [ + "pin-project-lite", +] + +[[package]] +name = "toml" +version = "1.1.8+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "20489e00e4d8741d6be680764cc12e270655e375a20d1011e844a9c3379e678d" +dependencies = [ + "indexmap", + "serde_core", + "serde_spanned", + "toml_datetime", + "toml_parser", + "toml_writer", + "winnow", +] + +[[package]] +name = "toml_datetime" +version = "1.1.2+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b86d767906c6c42421dcba507eb9d203e779497710a47782a224bb871653053" +dependencies = [ + "serde_core", +] + +[[package]] +name = "toml_edit" +version = "0.25.17+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3641d5bbb5349a79e1020a242d251efbc546ad8048d133958323ce9c40a9c9c" +dependencies = [ + "indexmap", + "toml_datetime", + "toml_parser", + "winnow", +] + +[[package]] +name = "toml_parser" +version = "1.1.5+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baa693a8032d7e1cada7d0041e96126df243179ff061456783ac7f12bda4744c" +dependencies = [ + "winnow", +] + +[[package]] +name = "toml_writer" +version = "1.1.3+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06bdbd8cfc056b8d2e2e85f29b56a3bdbecb527cef81eb39e3e7b98af4652770" + +[[package]] +name = "tracing" +version = "0.1.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100" +dependencies = [ + "pin-project-lite", + "tracing-attributes", + "tracing-core", +] + +[[package]] +name = "tracing-attributes" +version = "0.1.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "tracing-core" +version = "0.1.36" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a" +dependencies = [ + "once_cell", + "valuable", +] + +[[package]] +name = "tracing-log" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3" +dependencies = [ + "log", + "once_cell", + "tracing-core", +] + +[[package]] +name = "tracing-oslog" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d76902d2a8d5f9f55a81155c08971734071968c90f2d9bfe645fe700579b2950" +dependencies = [ + "cc", + "cfg-if", + "tracing-core", + "tracing-subscriber", +] + +[[package]] +name = "tracing-subscriber" +version = "0.3.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cb7f578e5945fb242538965c2d0b04418d38ec25c79d160cd279bf0731c8d319" +dependencies = [ + "matchers", + "nu-ansi-term", + "once_cell", + "regex-automata", + "sharded-slab", + "smallvec", + "thread_local", + "tracing", + "tracing-core", + "tracing-log", +] + +[[package]] +name = "tracing-wasm" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4575c663a174420fa2d78f4108ff68f65bf2fbb7dd89f33749b6e826b3626e07" +dependencies = [ + "tracing", + "tracing-subscriber", + "wasm-bindgen", +] + +[[package]] +name = "tree_magic_mini" +version = "3.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8765b90061cba6c22b5831f675da109ae5561588290f9fa2317adab2714d5a6" +dependencies = [ + "memchr", + "nom", + "petgraph", +] + +[[package]] +name = "ttf-parser" +version = "0.25.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2df906b07856748fa3f6e0ad0cbaa047052d4a7dd609e231c4f72cee8c36f31" + +[[package]] +name = "twox-hash" +version = "2.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "86a801b3cea342a06d468c8710662aa29e5e05e4f5c0d62f00bbb7f2ad7941c2" + +[[package]] +name = "typeid" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bc7d623258602320d5c55d1bc22793b57daff0ec7efc270ea7d55ce1d5f5471c" + +[[package]] +name = "typewit" +version = "1.15.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "214ca0b2191785cbc06209b9ca1861e048e39b5ba33574b3cedd58363d5bb5f6" + +[[package]] +name = "unicode-general-category" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b993bddc193ae5bd0d623b49ec06ac3e9312875fdae725a975c51db1cc1677f" + +[[package]] +name = "unicode-ident" +version = "1.0.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a2c754d6c33795a1c324727428e5a7dedb5b06195f9890bdbcba760d3e246563" + +[[package]] +name = "unicode-segmentation" +version = "1.13.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8" + +[[package]] +name = "unicode-width" +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 = "unsynn" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "501a7adf1a4bd9951501e5c66621e972ef8874d787628b7f90e64f936ef7ec0a" +dependencies = [ + "mutants", + "proc-macro2", + "rustc-hash 2.1.3", +] + +[[package]] +name = "untrusted" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1" + +[[package]] +name = "ureq" +version = "3.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7be76686bdf7198002062423ca0d8cf9b75a27c8e1de804513b97e97b555d9d" +dependencies = [ + "base64 0.23.1", + "flate2", + "log", + "percent-encoding", + "rustls", + "rustls-pki-types", + "ureq-proto", + "utf8-zero", + "webpki-roots", +] + +[[package]] +name = "ureq-proto" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "622dce33c252115466d83f63e9744a18f12b4406aae51a01c15ad8fcf1185eb3" +dependencies = [ + "base64 0.23.1", + "http", + "httparse", + "log", +] + +[[package]] +name = "utf8-zero" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8c0a043c9540bae7c578c88f91dda8bd82e59ae27c21baca69c8b191aaf5a6e" + +[[package]] +name = "utf8parse" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821" + +[[package]] +name = "uuid" +version = "1.29.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4a0e2d11620c50695fe12bbbfde96b3477fe606e7284c22d505c12ce51214514" +dependencies = [ + "getrandom 0.4.3", + "js-sys", + "serde_core", + "wasm-bindgen", +] + +[[package]] +name = "valuable" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65" + +[[package]] +name = "variadics_please" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b53d0f7f2d0182759a549f1f313ce16b07d8f9ba93098157b5fa10ee3e61117f" +dependencies = [ + "quote", + "unsynn", +] + +[[package]] +name = "vello_common" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b2e9aed918117e8152c9eddfd8362d73c465c23f26c44786aa331707b8a64fa2" +dependencies = [ + "bytemuck", + "fearless_simd", + "guillotiere", + "log", + "peniko", + "smallvec", + "thiserror 2.0.21", +] + +[[package]] +name = "vello_cpu" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac7349e1f55f6b801c7c277958df4ea53e7f20f21e8014910ad888b2ecda93ea" +dependencies = [ + "bytemuck", + "glifo", + "hashbrown 0.17.1", + "vello_common", +] + +[[package]] +name = "version_check" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" + +[[package]] +name = "walkdir" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b" +dependencies = [ + "same-file", + "winapi-util", +] + +[[package]] +name = "wasi" +version = "0.11.1+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b" + +[[package]] +name = "wasip2" +version = "1.0.4+wasi-0.2.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b67efb37e106e55ce722a510d6b5f9c17f083e5fc79afc2badeb12cc313d9487" +dependencies = [ + "wit-bindgen", +] + +[[package]] +name = "wasm-bindgen" +version = "0.2.129" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9bb54f33acc68fd454578d9820b0bde1a1a3d17aa17bb7b6595806d02886d409" +dependencies = [ + "cfg-if", + "once_cell", + "rustversion", + "wasm-bindgen-macro", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-futures" +version = "0.4.79" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3cbab34de2d982e9b48e18d216d04c4a6f641066ff19ffb699980f591ee3610e" +dependencies = [ + "js-sys", + "tokio", + "wasm-bindgen", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.129" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2e29d0c35b16e224a7eeb5cd2d25e3e1968fbd65604117b44d3b789d00ee8535" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.129" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6f501a8bc3719dba86ef8ae4728879c08001bea749eb1333ac5b91e040e2a6b7" +dependencies = [ + "bumpalo", + "proc-macro2", + "quote", + "syn 3.0.9", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.129" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "23f0c9c52aa7cd7d77769a4cfe2a9adb1b331f489a41d912ce14513d5ab995c6" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "wayland-backend" +version = "0.3.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38a91b4eaddff87b1cd1074985e3713da4af2c49742d1b356b2c01670a67a078" +dependencies = [ + "cc", + "downcast-rs 1.2.1", + "rustix 1.1.5", + "scoped-tls", + "smallvec", + "wayland-sys", +] + +[[package]] +name = "wayland-client" +version = "0.31.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3c36a0f861ad76d0901f2800b46321410d9f73f2ea88aac0650d86c32688073" +dependencies = [ + "bitflags 2.13.2", + "rustix 1.1.5", + "wayland-backend", + "wayland-scanner", +] + +[[package]] +name = "wayland-csd-frame" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "625c5029dbd43d25e6aa9615e88b829a5cad13b2819c4ae129fdbb7c31ab4c7e" +dependencies = [ + "bitflags 2.13.2", + "cursor-icon", + "wayland-backend", +] + +[[package]] +name = "wayland-cursor" +version = "0.31.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4a52d18780be9b1314328a3de5f930b73d2200112e3849ca6cb11822793fb34d" +dependencies = [ + "rustix 1.1.5", + "wayland-client", + "xcursor", +] + +[[package]] +name = "wayland-protocols" +version = "0.32.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "23d0c813de3daa2ed6520af85a3bd49b0e722a3078506899aa9686fea58dc4b6" +dependencies = [ + "bitflags 2.13.2", + "wayland-backend", + "wayland-client", + "wayland-scanner", +] + +[[package]] +name = "wayland-protocols-plasma" +version = "0.3.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b6d8cf1eb2c1c31ed1f5643c88a6e53538129d4af80030c8cabd1f9fa884d91" +dependencies = [ + "bitflags 2.13.2", + "wayland-backend", + "wayland-client", + "wayland-protocols", + "wayland-scanner", +] + +[[package]] +name = "wayland-protocols-wlr" +version = "0.3.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eb04e52f7836d7c7976c78ca0250d61e33873c34156a2a1fc9474828ec268234" +dependencies = [ + "bitflags 2.13.2", + "wayland-backend", + "wayland-client", + "wayland-protocols", + "wayland-scanner", +] + +[[package]] +name = "wayland-scanner" +version = "0.31.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "338e30461b3a2b67d70eb30a6d89f8e0c93a833e07d2ae89085cd070c4a00ac0" +dependencies = [ + "proc-macro2", + "quick-xml", + "quote", +] + +[[package]] +name = "wayland-sys" +version = "0.31.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8eab23fefc9e41f8e841df4a9c707e8a8c4ed26e944ef69297184de2785e3be" +dependencies = [ + "dlib", + "log", + "pkg-config", +] + +[[package]] +name = "weak-table" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5eba2ec791141b0bf4db542f6b038a8f9310cee33e076cb181245780b09a24ff" +dependencies = [ + "cfg-if", + "hashbrown 0.16.1", +] + +[[package]] +name = "web-sys" +version = "0.3.106" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "88261b9deccee56594c11a3460c462c41f58d148598fe70ad77070126a68aba4" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "web-task" +version = "1.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1cdc136a53ccd64a1211f107ccc34404769fbcc0f165f1afa065f5d88ab93538" +dependencies = [ + "async-task", + "cfg-if", + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "web-time" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "webpki-roots" +version = "1.0.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f5f280bbb2b287bc8e7de7e3852945a0ff50d1bbcb5ed42b6c7a568c546df171" +dependencies = [ + "rustls-pki-types", +] + +[[package]] +name = "wesl" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fdd8f9619baa4c7bde4df0899d6f626b70ee92d6e9c18c5f74473419b5bb6fa6" +dependencies = [ + "annotate-snippets", + "anstream", + "derive_more", + "glob", + "half", + "itertools 0.15.0", + "num-traits", + "serde", + "thiserror 2.0.21", + "toml", + "wesl-core", + "wesl-macros", + "wgsl-parse", + "wgsl-types", +] + +[[package]] +name = "wesl-core" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "84dd3e600497eda0b47afcd21bd84c8953a9dfce7e93ed27a38ba97ac0747e03" + +[[package]] +name = "wesl-macros" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac8767ec26e75262a8e581d5f188b1f63a288baaf885bb33c9f4f73a693e06fc" +dependencies = [ + "itertools 0.15.0", + "proc-macro2", + "quote", + "syn 3.0.9", +] + +[[package]] +name = "wgpu" +version = "30.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "527ccdf43dd5b2e8676eed9984ce00e2bbb0a1b85b70c1969dcb6cd2eb55ab9e" +dependencies = [ + "arrayvec", + "bitflags 2.13.2", + "bytemuck", + "cfg-if", + "cfg_aliases", + "document-features", + "hashbrown 0.17.1", + "log", + "portable-atomic", + "profiling", + "raw-window-handle", + "smallvec", + "static_assertions", + "wgpu-core", + "wgpu-hal", + "wgpu-types", +] + +[[package]] +name = "wgpu-core" +version = "30.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "14c018fce9b6270aa203c2fdd56f3cce996713534bd757e4ea58c8560b121f14" +dependencies = [ + "arrayvec", + "bit-set", + "bit-vec", + "bitflags 2.13.2", + "bytemuck", + "cfg_aliases", + "document-features", + "hashbrown 0.17.1", + "indexmap", + "log", + "naga", + "naga-types", + "once_cell", + "parking_lot", + "portable-atomic", + "profiling", + "raw-window-handle", + "rustc-hash 1.1.0", + "smallvec", + "thiserror 2.0.21", + "wgpu-core-deps-apple", + "wgpu-core-deps-windows-linux-android", + "wgpu-hal", + "wgpu-naga-bridge", + "wgpu-types", +] + +[[package]] +name = "wgpu-core-deps-apple" +version = "30.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "061f3d319a40d39d00b1ecc2c33b89fe21d4e6fe01859df3500a3a8ecccd6b68" +dependencies = [ + "wgpu-hal", +] + +[[package]] +name = "wgpu-core-deps-windows-linux-android" +version = "30.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7586165fd5f6d881cb9ce4bb71f40d6caab2c0f1837e3fc1d9788a197fb6004f" +dependencies = [ + "wgpu-hal", +] + +[[package]] +name = "wgpu-hal" +version = "30.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6b7fb58561a792bc237628ba0792e332de418fefe145f13b5ed8201e6d52f58" +dependencies = [ + "android_system_properties", + "arrayvec", + "ash", + "bit-set", + "bitflags 2.13.2", + "block2 0.6.2", + "bytemuck", + "cfg-if", + "cfg_aliases", + "gpu-allocator", + "hashbrown 0.17.1", + "libc", + "libloading", + "log", + "naga", + "naga-types", + "objc2 0.6.5", + "objc2-core-foundation", + "objc2-core-graphics", + "objc2-foundation 0.3.2", + "objc2-metal 0.3.2", + "objc2-quartz-core 0.3.2", + "once_cell", + "ordered-float", + "parking_lot", + "portable-atomic", + "portable-atomic-util", + "profiling", + "range-alloc", + "raw-window-handle", + "raw-window-metal", + "renderdoc-sys", + "smallvec", + "static_assertions", + "thiserror 2.0.21", + "wgpu-naga-bridge", + "wgpu-types", + "windows", + "windows-core", +] + +[[package]] +name = "wgpu-naga-bridge" +version = "30.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2f62e73117bb7a62bfd9c5a5841438a823f6566c6442a808ee269d2d055c081" +dependencies = [ + "naga", + "wgpu-types", +] + +[[package]] +name = "wgpu-types" +version = "30.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "99dad6f1fbdbbdb4c278a6508b059d44688f5cebddf78d005a46a31340269286" +dependencies = [ + "bitflags 2.13.2", + "bytemuck", + "js-sys", + "log", + "naga-types", + "raw-window-handle", + "serde", + "static_assertions", + "web-sys", +] + +[[package]] +name = "wgsl-parse" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37cee524ba5cfabfd65d10a316b646f8a4c50f3663e7e787471f21b783261f47" +dependencies = [ + "annotate-snippets", + "derive_more", + "itertools 0.15.0", + "lalrpop-util", + "lexical", + "logos", + "thiserror 2.0.21", + "wgsl-types", +] + +[[package]] +name = "wgsl-types" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e119dd12e57d937397535201959ddddb5dbf26505402db5ef305ebb1ca9a7e5f" +dependencies = [ + "half", + "itertools 0.15.0", + "num-traits", +] + +[[package]] +name = "winapi-util" +version = "0.1.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" +dependencies = [ + "windows-sys 0.61.2", +] + +[[package]] +name = "windows" +version = "0.62.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "527fadee13e0c05939a6a05d5bd6eec6cd2e3dbd648b9f8e447c6518133d8580" +dependencies = [ + "windows-collections", + "windows-core", + "windows-future", + "windows-numerics", +] + +[[package]] +name = "windows-collections" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "23b2d95af1a8a14a3c7367e1ed4fc9c20e0a26e79551b1454d72583c97cc6610" +dependencies = [ + "windows-core", +] + +[[package]] +name = "windows-core" +version = "0.62.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb" +dependencies = [ + "windows-implement", + "windows-interface", + "windows-link", + "windows-result", + "windows-strings", +] + +[[package]] +name = "windows-future" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1d6f90251fe18a279739e78025bd6ddc52a7e22f921070ccdc67dde84c605cb" +dependencies = [ + "windows-core", + "windows-link", + "windows-threading", +] + +[[package]] +name = "windows-implement" +version = "0.60.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "windows-interface" +version = "0.59.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + +[[package]] +name = "windows-numerics" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e2e40844ac143cdb44aead537bbf727de9b044e107a0f1220392177d15b0f26" +dependencies = [ + "windows-core", + "windows-link", +] + +[[package]] +name = "windows-result" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-strings" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-sys" +version = "0.52.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" +dependencies = [ + "windows-targets", +] + +[[package]] +name = "windows-sys" +version = "0.59.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" +dependencies = [ + "windows-targets", +] + +[[package]] +name = "windows-sys" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-targets" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" +dependencies = [ + "windows_aarch64_gnullvm", + "windows_aarch64_msvc", + "windows_i686_gnu", + "windows_i686_gnullvm", + "windows_i686_msvc", + "windows_x86_64_gnu", + "windows_x86_64_gnullvm", + "windows_x86_64_msvc", +] + +[[package]] +name = "windows-threading" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3949bd5b99cafdf1c7ca86b43ca564028dfe27d66958f2470940f73d86d75b37" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" + +[[package]] +name = "windows_i686_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" + +[[package]] +name = "windows_i686_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" + +[[package]] +name = "winit" +version = "0.30.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a6755fa58a9f8350bd1e472d4c3fcc25f824ec358933bba33306d0b63df5978d" +dependencies = [ + "ahash", + "android-activity", + "atomic-waker", + "bitflags 2.13.2", + "block2 0.5.1", + "bytemuck", + "calloop", + "cfg_aliases", + "concurrent-queue", + "core-foundation", + "core-graphics", + "cursor-icon", + "dpi", + "js-sys", + "libc", + "memmap2", + "ndk", + "objc2 0.5.3", + "objc2-app-kit 0.2.2", + "objc2-foundation 0.2.2", + "objc2-ui-kit", + "orbclient", + "percent-encoding", + "pin-project", + "raw-window-handle", + "redox_syscall 0.4.1", + "rustix 0.38.44", + "sctk-adwaita", + "smithay-client-toolkit", + "smol_str", + "tracing", + "unicode-segmentation", + "wasm-bindgen", + "wasm-bindgen-futures", + "wayland-backend", + "wayland-client", + "wayland-protocols", + "wayland-protocols-plasma", + "web-sys", + "web-time", + "windows-sys 0.52.0", + "x11-dl", + "x11rb", + "xkbcommon-dl", +] + +[[package]] +name = "winnow" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "23b97319f7b8343df12cc98938e5c3eb436064524c8d2b4e30a1d3a36eecdf81" +dependencies = [ + "memchr", +] + +[[package]] +name = "wit-bindgen" +version = "0.57.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e" + +[[package]] +name = "wl-clipboard-rs" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "959c7ac3b8afde864f7a7448ac16f29b2b83350b7eccbf77fb781c3999aa6848" +dependencies = [ + "libc", + "log", + "os_pipe", + "rustix 1.1.5", + "thiserror 2.0.21", + "tree_magic_mini", + "wayland-backend", + "wayland-client", + "wayland-protocols", + "wayland-protocols-wlr", +] + +[[package]] +name = "x11-dl" +version = "2.21.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38735924fedd5314a6e548792904ed8c6de6636285cb9fec04d5b1db85c1516f" +dependencies = [ + "libc", + "once_cell", + "pkg-config", +] + +[[package]] +name = "x11rb" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9993aa5be5a26815fe2c3eacfc1fde061fc1a1f094bf1ad2a18bf9c495dd7414" +dependencies = [ + "as-raw-xcb-connection", + "gethostname", + "libc", + "libloading", + "once_cell", + "rustix 1.1.5", + "x11rb-protocol", +] + +[[package]] +name = "x11rb-protocol" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea6fc2961e4ef194dcbfe56bb845534d0dc8098940c7e5c012a258bfec6701bd" + +[[package]] +name = "xcursor" +version = "0.3.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "163b33ed8786455e2fa5d72f554057ce3f3182425434f756cd39c99839d88e23" + +[[package]] +name = "xkbcommon-dl" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d039de8032a9a8856a6be89cea3e5d12fdd82306ab7c94d74e6deab2460651c5" +dependencies = [ + "bitflags 2.13.2", + "dlib", + "log", + "once_cell", + "xkeysym", +] + +[[package]] +name = "xkeysym" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9cc00251562a284751c9973bace760d86c0276c471b4be569fe6b068ee97a56" + +[[package]] +name = "zerocopy" +version = "0.8.63" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5fe1f8f1b06191a00962174c61aa5005e0bb391a6d80d07e24d115c01a92ed8" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.63" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "863ad3ac83293fb4d740aedbfdc9240dd8d1a50c1099acd76ce80ce7c7230c7f" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "zeroize" +version = "1.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e13084392c5e4bc371903e2935a5eaeed24905a7511356b883835e18a78f6879" + +[[package]] +name = "zlib-rs" +version = "0.6.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b268e58e7c693d7c271f93ffc4ba3b380412554231c85bf61ca7af91042a4112" + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 0000000..8e6f2f7 --- /dev/null +++ b/Cargo.toml @@ -0,0 +1,34 @@ +[package] +name = "cellstage" +version = "0.1.0" +edition = "2024" +rust-version = "1.97" +authors = ["Nicolas Godzik"] +license = "MIT" +description = "A stage an agent draws biology on: proteins, cells, tissues, and cellweave's simulations, driven over MCP." +publish = false + +[dependencies] +cellweave-core = { git = "https://github.com/ngodzik/cellweave", tag = "v0.3.0", version = "0.3.0" } +cellweave-engine = { git = "https://github.com/ngodzik/cellweave", tag = "v0.3.0", version = "0.3.0" } +cellweave-io = { git = "https://github.com/ngodzik/cellweave", tag = "v0.3.0", version = "0.3.0" } +anyhow = "1" +base64 = "0.22" +png = "0.18" +rayon = "1" +serde = { version = "1", features = ["derive"] } +serde_json = "1" +ureq = "3" +bevy = { version = "0.20.0", default-features = false, features = [ + "std", "async_executor", "multi_threaded", "bevy_log", "bevy_winit", "bevy_window", + "x11", "wayland", "bevy_render", "bevy_core_pipeline", "bevy_asset", "bevy_color", "hdr", + "bevy_post_process", "bevy_camera", "bevy_mesh", "bevy_image", "bevy_shader", "bevy_material", + "bevy_pbr", "bevy_light", "bevy_anti_alias", "mouse", "keyboard", "png", +] } +bevy_egui = { version = "0.43.1", default-features = false, features = ["render", "default_fonts"] } + +[profile.dev] +opt-level = 1 + +[profile.dev.package."*"] +opt-level = 3 diff --git a/README.md b/README.md index f5091e6..c85c128 100644 --- a/README.md +++ b/README.md @@ -1 +1,79 @@ -# cellstage \ No newline at end of file +# cellstage + +[![CI](https://github.com/ngodzik/cellstage/actions/workflows/ci.yml/badge.svg)](https://github.com/ngodzik/cellstage/actions/workflows/ci.yml) [![Security](https://github.com/ngodzik/cellstage/actions/workflows/security.yml/badge.svg)](https://github.com/ngodzik/cellstage/actions/workflows/security.yml) + +A window an agent tells biology on, step by step. + +cellstage is a [Model Context Protocol](https://modelcontextprotocol.io) server and a window. An agent connected to it, Claude Code in a terminal or any other client, tells a story in steps, and the user moves through them with the arrow keys, as through a course. Each step has a few words, shown under the pictures, and one to six panels showing: + +- **worlds in three dimensions, built cell by cell ahead of time, that the agent films**. The agent directs: a film of shots, each a place the camera flies to, the words said over it as subtitles, how far the world's clock runs meanwhile, and what stands out while the rest dims. The window renders and plays it, with life moving all the while, and the user can pause it, scrub through it, take the camera and click on cells. The worlds: + - from a forearm seen at a hand's length, its surface with its lines and pores, through the surface into a core of skin half a millimetre across, every cell in place: the horny, granular, spiny and basal layers of the epidermis, the melanocytes among the basal cells handing pigment up their arms to the keratinocytes, the basement membrane over the rete ridges, the dermis with its collagen, fibroblasts and capillary loops with red cells running through them; + - down into one melanocyte's nucleus, its envelope and pores, its chromatin, the string of nucleosomes, and the double helix at codon 600 of BRAF, base pair by base pair: nine orders of magnitude in one move of the camera, each part drawn at the scales it is seen at; + - a clock that tells a common mole, or a melanoma: BRAF mutating in that melanocyte (its T becoming an A on screen), the clone dividing and gathering in nests at the bottoms of the rete ridges while a brown spot grows at the surface; then either the clone stopping for decades and its nests sinking into the dermis as the mole grows raised and paler, or one cell losing p16 and its clone spreading through the epidermis, digesting the basement membrane, filling a nodule in the dermis that capillaries sprout towards, and leaving in the blood, while mutations pile up in its DNA and the spot at the surface grows uneven in shape and colour; + - three more worlds for the hallmarks of cancer Hanahan and Weinberg named: **growth_signals**, a cell reading a growth factor from its receptors through RAS, RAF, MEK and ERK to RB and E2F on its genes, with RAS stuck on or p16 lost; **cell_death**, a cell with broken DNA dying by apoptosis, p53, BAX, cytochrome c, apoptosome and caspases, its bodies eaten by a macrophage, or living on with BCL2 high or p53 lost; **telomeres**, a metaphase spread whose telomeres wear down with each division until they set off the alarm, unless telomerase writes them back, or until the chromosomes fuse in crisis; +- **proteins** at the atomic structure their authors measured, any entry of the Protein Data Bank, or as the AlphaFold database predicts any human protein, as atoms or as their fold, with residues highlighted, notes pinned to residues as the protein turns, and a slider between two states of the same protein; +- **one cell under a fluorescence microscope**, its protein network run live by [cellweave](https://github.com/ngodzik/cellweave): oxygen, growth factor and stress set by the agent, genes removed or stuck on, each stained protein glowing where it lives, the cell cycling, arresting, taking itself apart or bursting by cellweave's thresholds; +- **stained sections of skin**, normal or with a melanocytic lesion at one of ten stages, from a junctional nevus to a nodular melanoma, drawn in haematoxylin and eosin from the criteria histology uses to tell them apart. + +The agent points at things by name, a place in a world, a section or a cell, a residue, and the window places the note beside it and follows it as it moves. It can look things up as it tells: proteins in UniProt and the PDB, pathways in Reactome. The window makes everything it shows: it shows no pictures from anywhere else, and the agent draws nothing in it, no drawing, diagram or chart. When a subject is in none of its worlds, and is not a protein, the live cell or a section of skin, the agent is told to say that cellstage cannot show it yet, rather than draw it instead. The user turns and zooms what is shown and clicks on things; the agent hears what was clicked, and which step the user went to. The teaching is the agent's: cellstage only shows. + +## The library + +Every story is kept on disk as it is told, every step with what fills it, under `~/.local/share/cellstage` (or `$CELLSTAGE_HOME`): one JSON file per story. An agent searches the library before building anything, and a story told once opens again at once, in another conversation, another day. The user can open any story from the window's library, without the agent. + +## What a panel is + +Every panel carries a label, so that an illustration is never taken for a measurement or a result: + +- **measured structure**: atoms where X-ray crystallography or cryo-electron microscopy placed them; the colours are chosen. +- **predicted structure**: atoms where AlphaFold predicts them, never measured; the agent is told which stretches are predicted with low confidence. +- **simulation**: protein levels and fate computed by cellweave's network; how the cell looks, its outline and organelles and the microscope's optics, is drawn. +- **illustration**: a world built from what histology describes, or a section drawn from it; neither is simulated. A world's mole grows along the course the textbooks describe, laid out ahead of time, not computed. + +## Running it + +It builds against cellweave's crates at version 0.3.0, the first with the fuller cell of its chapter 28, which Cargo fetches from GitHub: + +```sh +git clone https://github.com/ngodzik/cellstage.git +cd cellstage +cargo build --release +claude mcp add -s user cellstage -- "$(pwd)/target/release/cellstage" +``` + +Then, in a new Claude Code session, ask for something to be shown or explained. The window opens at the first thing shown; closing it hides it until the next. + +## The tools + +| tool | what it does | +|---|---| +| `library_search` | finds kept stories by subject | +| `story_open` | opens a kept story at one of its steps | +| `story_new`, `story_step` | begins a story; adds a step after the one on screen, empty or with the same panels | +| `story_edit`, `story_goto`, `story_remove_step` | changes a step's words, shows a step, removes one | +| `stage_layout` | splits the step into one to six panels, side by side, stacked, or in a grid | +| `show_world` | a 3D world in a panel, and the film the agent directs in it: places, words, the world's clock, what stands out | +| `protein_search` | human proteins in UniProt with what each does, and structures in the PDB, from a name | +| `pathway_lookup` | pathways and reactions in Reactome, with their steps, inputs and outputs | +| `show_protein` | a PDB entry, or the AlphaFold prediction for a UniProt accession, in a panel; its answer lists chains, residue numbers and bound molecules | +| `show_cell` | the cell under the microscope, its setting, its stains; its answer gives every level and the fate | +| `show_skin` | an H&E section at a named stage; its answer gives the Breslow thickness of an invasive melanoma | +| `annotate`, `clear_annotations` | notes on a panel, pointing at a named place, a residue, or a spot | +| `focus_protein` | turns a protein's camera to a residue | +| `get_user_events` | what the user clicked, and the steps they moved to, since the last call | +| `screenshot` | a picture of the window, for the agent to see what it shows | + +## Data + +No structure, picture or record from elsewhere is stored in the project. What the window fetches, it fetches once and keeps in the user's cache, `~/.cache/cellstage`: + +- structures from the RCSB; the wwPDB places the archive's files under CC0; +- predicted structures from the [AlphaFold database](https://alphafold.ebi.ac.uk), under CC BY 4.0; +- what proteins do, from [UniProt](https://www.uniprot.org), under CC BY 4.0; +- pathways from [Reactome](https://reactome.org), under CC BY 4.0. + +The H&E colours follow the Beer-Lambert law with the haematoxylin and eosin stain vectors of Ruifrok and Johnston (Anal Quant Cytol Histol 23, 291-299, 2001). + +## License + +MIT. See [LICENSE](LICENSE). diff --git a/deny.toml b/deny.toml new file mode 100644 index 0000000..7b503bb --- /dev/null +++ b/deny.toml @@ -0,0 +1,61 @@ +# Configuration for cargo-deny, run by .github/workflows/security.yml. +# +# Three questions, none of which the compiler answers: is a dependency subject +# to a published advisory, is its licence compatible with shipping this under +# MIT, and did it come from somewhere other than crates.io or cellweave. + +[advisories] +version = 2 +# An entry here is a decision to live with a known vulnerability, and it +# carries the advisory identifier and the reason. +ignore = [ + # ttf-parser is unmaintained, with no replacement released. winit reaches + # it through sctk-adwaita, which draws the window's title bar on Wayland + # with a font of the system; no font from outside is ever parsed with it. + # To revisit when winit or sctk-adwaita moves off it. + { id = "RUSTSEC-2026-0192", reason = "winit parses only system fonts with it, for the Wayland title bar" }, + # ruzstd 0.8 can be made to allocate without bound by a crafted input, + # fixed in 0.9.1, which bevy_image 0.20 does not accept yet. bevy_image + # uses it only to decompress KTX2 textures, and cellstage loads none: its + # textures are painted in code. To revisit when Bevy moves to ruzstd 0.9. + { id = "RUSTSEC-2026-0344", reason = "bevy_image decompresses only KTX2 textures with it, and none is loaded" }, +] + +[licenses] +version = 2 +# Derived from the dependency tree as it actually stands, not from a template. +# A new licence appearing here is a fact worth being told about. +allow = [ + "MIT", + "Apache-2.0", + "Apache-2.0 WITH LLVM-exception", + "BSD-2-Clause", + "Unicode-3.0", + "Unlicense", + # Bevy, winit and the graphics stack. + "Zlib", + "MIT-0", + "ISC", + "BSD-3-Clause", + # The fonts egui draws its panels with, bundled into the binary: free to + # embed and redistribute, which is all a window does with them. + "OFL-1.1", + "Ubuntu-font-1.0", + # Mozilla's list of certificate authorities, which ureq trusts when it + # fetches a protein from the PDB or AlphaFold: a permissive data licence. + "CDLA-Permissive-2.0", +] +confidence-threshold = 0.9 + +[bans] +multiple-versions = "warn" +# A dependency pinned to "*" takes whatever version the registry happens to hold, +# which is a supply chain risk worth refusing. +wildcards = "deny" + +[sources] +unknown-registry = "deny" +unknown-git = "deny" +allow-registry = ["https://github.com/rust-lang/crates.io-index"] +# cellweave's crates come from its repository, by a release tag. +allow-git = ["https://github.com/ngodzik/cellweave"] diff --git a/src/cell/dish.rs b/src/cell/dish.rs new file mode 100644 index 0000000..90ff695 --- /dev/null +++ b/src/cell/dish.rs @@ -0,0 +1,307 @@ +//! One cell in a dish, its network running live: the fuller cell of +//! chapter 28, under an oxygen, a growth factor and a stress the learner +//! sets, with any of its genes removed or stuck on. +//! +//! The network is cellweave's own, compiled and stepped by the engine; what +//! the cell does with its levels is decided against the engine's own +//! thresholds. Nothing here is drawn for effect except how the dish looks, +//! which is the microscope's business. + +use cellweave_core::network::Term; +use cellweave_core::{CellInputs, Concentration, NetworkSpec, SignalingNetwork, TimeStep}; +use cellweave_engine::Network; +use cellweave_engine::simulation::{DEATH_THRESHOLD, QUIESCENCE_THRESHOLD}; + +/// Units of network time per step of the dish: the engine's own, so a step +/// here is a lattice step there. +const NETWORK_TIME_PER_STEP: u32 = 8; + +/// Steps a cycling cell takes from one division to the next: the median of +/// the cycles chapter 27 draws. +pub const CYCLE_STEPS: f32 = 20.0; + +/// The growth factor every cell of a simulation reads. +pub const USUAL_EGF: f64 = 0.2; + +/// The fuller cell's proteins, by the names its network file gives them. +pub const GENES: [&str; 18] = [ + "ras", "erk", "hif1", "vegf", "bcl2", "p53", "caspase", "egfr", "raf", "mek", "cyclin_d", "rb", + "e2f", "cyclin_e", "p27", "p21", "mdm2", "bax", +]; + +/// How a protein of the network is written for a reader. +pub fn label(name: &str) -> &str { + match name { + "egfr" => "EGFR", + "ras" => "RAS", + "raf" => "RAF", + "mek" => "MEK", + "erk" => "ERK", + "hif1" => "HIF-1α", + "vegf" => "VEGF", + "bcl2" => "BCL2", + "bax" => "BAX", + "mdm2" => "MDM2", + "rb" => "RB", + "e2f" => "E2F", + "cyclin_d" => "cyclin D", + "cyclin_e" => "cyclin E", + other => other, + } +} + +/// What has been done to a gene. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum Switch { + /// Nothing: the protein follows its terms. + Normal, + /// Removed: the protein is never made. + Removed, + /// Stuck on, as chapter 2's RAS mutant: held near full activity by + /// nothing upstream. + StuckOn, +} + +/// What the cell is doing. +#[derive(Debug, Clone, Copy, PartialEq)] +pub enum Fate { + /// Alive and going round its cycle, this far through it. + Cycling(f32), + /// Alive, its cycle stopped. + Arrested, + /// Taking itself apart, this far through. + Apoptotic(f32), + /// Dead of energy failure, this far through swelling and bursting. + Necrotic(f32), +} + +impl Fate { + /// Whether the cell is still alive. + pub fn alive(&self) -> bool { + matches!(self, Fate::Cycling(_) | Fate::Arrested) + } +} + +/// The cell, and what it sits in. +pub struct Dish { + /// The network as the file states it. + spec: NetworkSpec, + /// The network as the switches leave it, running. + network: Network, + /// What it reads: the share of the source's oxygen, the growth factor, + /// the stress. + pub oxygen: f64, + pub egf: f64, + pub stress: f64, + /// What has been done to each gene, by node. + switches: Vec, + pub fate: Fate, + /// Steps taken since the dish was last reset. + pub steps: u64, + /// Divisions since then. + pub divisions: u32, + /// Every step's levels, oldest first, for the plot. + pub history: Vec>, + /// The state of the dish's own random draws, for apoptosis. + seed: u64, +} + +impl Dish { + /// A well-fed cell with every gene as it is, carrying the fuller cell + /// that cellweave ships. + pub fn new() -> anyhow::Result { + let spec = cellweave_io::shipped_network("fuller-cell") + .map_err(|e| anyhow::anyhow!("the fuller cell: {e}"))?; + let network = Network::from_spec(&spec, 200).map_err(|e| anyhow::anyhow!("{e}"))?; + let switches = vec![Switch::Normal; spec.nodes.len()]; + Ok(Self { + spec, + network, + oxygen: 1.0, + egf: USUAL_EGF, + stress: 0.0, + switches, + fate: Fate::Cycling(0.0), + steps: 0, + divisions: 0, + history: Vec::new(), + seed: 0x9E37_79B9_7F4A_7C15, + }) + } + + /// The proteins, by the names the file gives them. + pub fn names(&self) -> &[String] { + self.network.node_names() + } + + /// Every protein's level now. + pub fn levels(&self) -> Vec { + self.network.state().values.iter().map(|c| c.0).collect() + } + + /// What has been done to a gene. + pub fn switch(&self, node: usize) -> Switch { + self.switches.get(node).copied().unwrap_or(Switch::Normal) + } + + /// Remove a gene, stick it on, or put it back; the network is rebuilt + /// from where its levels are now. + pub fn set_switch(&mut self, node: usize, switch: Switch) { + if self.switch(node) == switch || node >= self.switches.len() { + return; + } + self.switches[node] = switch; + let levels = self.levels(); + self.network = self.compiled(&levels); + } + + /// The network as the switches leave it, starting from `levels`. + fn compiled(&self, levels: &[f64]) -> Network { + let spec = switched(&self.spec, &self.switches, levels); + Network::from_spec(&spec, 200).unwrap_or_else(|_| self.network.clone()) + } + + /// What the cell reads. + pub fn inputs(&self) -> CellInputs { + inputs(self.oxygen, self.egf, self.stress) + } + + /// One step: the network runs for a lattice step's worth of its time, + /// then the cell is judged as the engine judges it. + pub fn step(&mut self) { + if !self.fate.alive() { + self.fate = match self.fate { + Fate::Apoptotic(p) => Fate::Apoptotic((p + 0.08).min(1.0)), + Fate::Necrotic(p) => Fate::Necrotic((p + 0.05).min(1.0)), + other => other, + }; + return; + } + let inputs = self.inputs(); + for _ in 0..NETWORK_TIME_PER_STEP { + self.network.step(TimeStep(1.0), &inputs); + } + self.steps += 1; + self.history.push(self.levels()); + if self.history.len() > 600 { + self.history.remove(0); + } + let draw = self.draw(); + self.fate = if self.network.survival() < DEATH_THRESHOLD { + Fate::Necrotic(0.0) + } else if self.network.apoptosis().is_some_and(|chance| draw < chance) { + Fate::Apoptotic(0.0) + } else if self.network.hypoxia_response() >= QUIESCENCE_THRESHOLD { + Fate::Arrested + } else { + let through = match self.fate { + Fate::Cycling(t) => t, + _ => 0.0, + } + 1.0 / CYCLE_STEPS; + if through >= 1.0 { + self.divisions += 1; + } + Fate::Cycling(through.fract()) + }; + } + + /// A uniform draw in [0, 1), from a generator of the dish's own. + fn draw(&mut self) -> f64 { + // xorshift64*: enough for a chance per step. + let mut x = self.seed; + x ^= x >> 12; + x ^= x << 25; + x ^= x >> 27; + self.seed = x; + (x.wrapping_mul(0x2545_F491_4F6C_DD1D) >> 11) as f64 / (1u64 << 53) as f64 + } + + /// The index of a protein, by name. + pub fn index(&self, name: &str) -> Option { + self.names().iter().position(|n| n == name) + } +} + +/// The inputs a cell reads, crowding aside: a cell alone in a dish is not +/// squeezed. +fn inputs(oxygen: f64, egf: f64, stress: f64) -> CellInputs { + CellInputs { + o2: Concentration(oxygen), + egf: Concentration(egf), + vegf: Concentration(0.0), + crowding: Concentration(0.0), + stress: Concentration(stress), + waste: Concentration(0.0), + necrotic_factor: Concentration(0.0), + } +} + +/// `spec` with each gene as `switches` says, every node starting at +/// `levels`. +fn switched(spec: &NetworkSpec, switches: &[Switch], levels: &[f64]) -> NetworkSpec { + let mut spec = spec.clone(); + for (i, node) in spec.nodes.iter_mut().enumerate() { + node.initial = levels.get(i).copied().unwrap_or(node.initial); + match switches.get(i).copied().unwrap_or(Switch::Normal) { + Switch::Normal => {} + Switch::Removed => { + // Never made, and what there was is gone within a step. + node.terms = vec![Term::Decays { rate: 1.0 }]; + } + Switch::StuckOn => { + // Chapter 2's mutant RAS: held on by nothing upstream. + node.terms = vec![ + Term::RelaxesTo { + value: 1.0, + rate: 0.5, + }, + Term::Decays { rate: 0.3 }, + ]; + } + } + } + spec +} + +#[cfg(test)] +mod tests { + use super::*; + + fn level(dish: &Dish, name: &str) -> f64 { + dish.levels()[dish.index(name).unwrap()] + } + + #[test] + fn a_fed_cell_cycles_and_a_starved_one_stops_where_the_engine_says() { + let mut dish = Dish::new().unwrap(); + for _ in 0..30 { + dish.step(); + } + assert!(matches!(dish.fate, Fate::Cycling(_)), "{:?}", dish.fate); + assert!(dish.divisions >= 1); + dish.oxygen = 0.2; + for _ in 0..10 { + dish.step(); + } + assert_eq!(dish.fate, Fate::Arrested); + assert!(level(&dish, "rb") >= QUIESCENCE_THRESHOLD); + } + + #[test] + fn a_removed_gene_falls_to_nothing_and_one_stuck_on_rises() { + let mut dish = Dish::new().unwrap(); + let mdm2 = dish.index("mdm2").unwrap(); + let ras = dish.index("ras").unwrap(); + dish.stress = 0.5; + dish.set_switch(mdm2, Switch::Removed); + dish.set_switch(ras, Switch::StuckOn); + for _ in 0..5 { + dish.step(); + if !dish.fate.alive() { + break; + } + } + assert!(level(&dish, "mdm2") < 1e-3); + assert!(level(&dish, "ras") > 0.5); + } +} diff --git a/src/cell/mod.rs b/src/cell/mod.rs new file mode 100644 index 0000000..dcf49e1 --- /dev/null +++ b/src/cell/mod.rs @@ -0,0 +1,6 @@ +//! One cell under a fluorescence microscope, its protein network running: +//! the fuller cell of cellweave's chapter 28, in a dish, and how a +//! microscope would show it. + +pub mod dish; +pub mod specimen; diff --git a/src/cell/specimen.rs b/src/cell/specimen.rs new file mode 100644 index 0000000..843d56d --- /dev/null +++ b/src/cell/specimen.rs @@ -0,0 +1,765 @@ +//! A cell as a fluorescence microscope shows it: dark, with each stained +//! protein glowing where it sits in the cell. +//! +//! The cell's architecture is drawn once, from a seed: its outline, its +//! nucleus with chromatin and nucleoli, its mitochondria, its Golgi +//! apparatus and its vesicles, each a layer of where the cell holds that +//! compartment. What is not drawn is how bright each protein is: a protein +//! is a mix of the layers it lives in, as bright as the network running in +//! the dish says it is. The optics are a microscope's: every layer blurred by +//! the point spread function of the lens, a faint haze of out-of-focus +//! light, and the grain of a camera counting photons. + +use std::f32::consts::{PI, TAU}; + +use bevy::math::Vec2; + +use super::dish::Fate; + +/// The image's side, in pixels. +pub const SIZE: usize = 720; + +/// Micrometres per pixel: the cell is about 35 µm across, its nucleus 13, +/// as a cultured cell spread on glass is. +pub const MICROMETRES_PER_PIXEL: f32 = 0.0715; + +/// Where in the cell something is. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum Compartment { + /// Not the cell. + Outside, + /// The membrane around the cell. + Membrane, + /// The fluid between the membrane and the nucleus. + Cytosol, + /// The nucleus, where the DNA is. + Nucleus, + /// The nucleolus, inside the nucleus, where ribosomes are made. + Nucleolus, + /// A mitochondrion. + Mitochondrion, + /// The Golgi apparatus, beside the nucleus. + Golgi, + /// A vesicle carrying something to the surface or from it. + Vesicle, +} + +impl Compartment { + /// Its name. + pub fn name(self) -> &'static str { + match self { + Compartment::Outside => "outside the cell", + Compartment::Membrane => "the cell membrane", + Compartment::Cytosol => "the cytosol", + Compartment::Nucleus => "the nucleus", + Compartment::Nucleolus => "a nucleolus", + Compartment::Mitochondrion => "a mitochondrion", + Compartment::Golgi => "the Golgi apparatus", + Compartment::Vesicle => "a vesicle", + } + } + + /// What it is, in a sentence. + pub fn what(self) -> &'static str { + match self { + Compartment::Outside => "The glass the cell is spread on, and the medium above it.", + Compartment::Membrane => { + "A double layer of lipids, 5 nanometres thick, around the whole cell. Receptors such as EGFR cross it; RAS hangs on its inner face." + } + Compartment::Cytosol => { + "The crowded fluid that fills the cell around the organelles, where RAF, MEK and the caspases work." + } + Compartment::Nucleus => { + "Where the DNA is, inside a double membrane. Transcription factors such as p53, HIF-1α and E2F work here, switching genes on." + } + Compartment::Nucleolus => { + "A dense region of the nucleus where ribosomes are assembled. It holds little DNA, so the DNA stain is dark there." + } + Compartment::Mitochondrion => { + "Where the cell burns its fuel with oxygen to make ATP. BCL-2 sits in its outer membrane; activated BAX opens pores there, and cytochrome c leaks out to start apoptosis." + } + Compartment::Golgi => { + "Stacks of membrane beside the nucleus that sort and package proteins made for export, such as VEGF, into vesicles." + } + Compartment::Vesicle => { + "A small membrane bubble, carrying cargo to the surface, such as VEGF to be secreted, or in from it, such as receptors taken back." + } + } + } +} + +/// The layers a protein can be in, in the order the specimen holds them. +const DNA: usize = 0; +const NUCLEOPLASM: usize = 1; +const CYTOSOL: usize = 2; +const MEMBRANE: usize = 3; +const MITOCHONDRIA: usize = 4; +const GOLGI: usize = 5; +const VESICLES: usize = 6; +const FRAGMENTS: usize = 7; +const LAYERS: usize = 8; + +/// One channel of the image: what is stained, how bright it is, and the +/// colour of its dye. +#[derive(Debug, Clone, Copy)] +pub struct Channel { + /// How much of each layer the stained thing is in. + pub layers: [f32; LAYERS], + /// How much of it there is: its level in the network, or one for a + /// stain of the structure itself. + pub amount: f32, + /// The dye's colour, linear RGB. + pub colour: [f32; 3], + /// The camera's gain for this channel. + pub gain: f32, +} + +/// The dyes the microscope's channels are read in. +pub const BLUE: [f32; 3] = [0.20, 0.42, 1.0]; +pub const GREEN: [f32; 3] = [0.15, 1.0, 0.25]; +pub const RED: [f32; 3] = [1.0, 0.12, 0.08]; +pub const MAGENTA: [f32; 3] = [0.95, 0.15, 1.0]; + +/// The cell's architecture, drawn once. +pub struct Specimen { + layers: Vec>, + centre: Vec2, + radius: f32, + /// The outline's harmonics: amplitude and phase of each. + harmonics: Vec<(f32, f32)>, + /// The nucleus: centre, half axes, angle. + nucleus: (Vec2, Vec2, f32), + /// The nucleoli: centre and radius. + nucleoli: Vec<(Vec2, f32)>, +} + +impl Specimen { + /// Draw a cell from a seed. + pub fn new(seed: u32) -> Self { + let s = SIZE as f32; + let mut random = Random(seed.wrapping_mul(2_654_435_761).max(1)); + let centre = Vec2::splat(s / 2.0); + let radius = 0.34 * s; + let harmonics: Vec<(f32, f32)> = (2..8) + .map(|k| { + ( + 0.14 / k as f32 * random.between(0.6, 1.2), + random.between(0.0, TAU), + ) + }) + .collect(); + let nucleus = ( + centre + Vec2::new(0.10 * radius, -0.06 * radius), + Vec2::new(0.36 * radius, 0.28 * radius), + random.between(0.0, PI), + ); + let nucleoli: Vec<(Vec2, f32)> = (0..3) + .map(|_| { + let a = random.between(0.0, TAU); + let d = random.between(0.1, 0.55); + let offset = Vec2::new(a.cos() * nucleus.1.x * d, a.sin() * nucleus.1.y * d); + ( + nucleus.0 + rotate(offset, nucleus.2), + random.between(0.028, 0.045) * radius, + ) + }) + .collect(); + let mut specimen = Self { + layers: vec![vec![0.0; SIZE * SIZE]; LAYERS], + centre, + radius, + harmonics, + nucleus, + nucleoli, + }; + specimen.draw(&mut random, seed); + for layer in &mut specimen.layers { + *layer = optics(layer); + } + specimen + } + + /// The outline's radius in direction `angle`. + fn rim(&self, angle: f32) -> f32 { + let wobble: f32 = self + .harmonics + .iter() + .enumerate() + .map(|(i, (a, phase))| a * ((i as f32 + 2.0) * angle + phase).cos()) + .sum(); + self.radius * (1.0 + wobble) + } + + /// How far `p` is inside the nucleus: below one inside, one on its + /// envelope. + fn in_nucleus(&self, p: Vec2) -> f32 { + let (c, axes, angle) = self.nucleus; + let q = rotate(p - c, -angle); + ((q.x / axes.x).powi(2) + (q.y / axes.y).powi(2)).sqrt() + } + + /// How deep `p` is in the cell: one at its centre, zero on its outline, + /// negative outside; and the distance to the outline in pixels. + fn depth(&self, p: Vec2) -> (f32, f32) { + let d = p - self.centre; + let rim = self.rim(d.y.atan2(d.x)); + let r = d.length(); + (1.0 - r / rim, rim - r) + } + + /// Draw every layer, before the optics. + fn draw(&mut self, random: &mut Random, seed: u32) { + let s = seed; + for y in 0..SIZE { + for x in 0..SIZE { + let p = Vec2::new(x as f32, y as f32); + let i = y * SIZE + x; + let (depth, to_rim) = self.depth(p); + if depth <= -0.02 { + continue; + } + let inside = smooth(-1.0, 1.0, to_rim); + let e = self.in_nucleus(p); + let in_nucleus = 1.0 - smooth(0.96, 1.02, e); + let nucleolus = self + .nucleoli + .iter() + .map(|(c, r)| 1.0 - smooth(0.8 * r, 1.1 * r, p.distance(*c))) + .fold(0.0, f32::max); + // Chromatin: grainy, denser against the envelope, thin in + // the nucleoli. + let grain = fbm(p * 0.11, s, 4); + let clumps = fbm(p * 0.035, s + 3, 3); + let chromatin = + (0.15 + 1.4 * (grain - 0.35).max(0.0) + 0.6 * (clumps - 0.4).max(0.0)).min(1.2); + let envelope = (-((1.0 - e) / 0.07).powi(2)).exp(); + self.layers[DNA][i] = in_nucleus + * (0.25 + 0.75 * chromatin + 0.35 * envelope) + * (1.0 - 0.75 * nucleolus); + // Proteins of the nucleoplasm: fairly even, finely speckled, + // fewer in the nucleoli. + let speckle = 0.75 + 0.25 * fbm(p * 0.21, s + 7, 2); + self.layers[NUCLEOPLASM][i] = in_nucleus * speckle * (1.0 - 0.6 * nucleolus); + // The cytosol: thicker, so brighter, towards the middle of + // the cell, thin at its edges. + let thickness = depth.max(0.0).sqrt(); + let texture = 0.8 + 0.2 * fbm(p * 0.03, s + 11, 3); + self.layers[CYTOSOL][i] = + inside * (1.0 - in_nucleus) * (0.25 + 0.75 * thickness) * texture; + // The membrane: bright where it is seen edge on, at the + // outline, faint over the top of the cell. + let edge = (-(to_rim / 1.8).powi(2)).exp(); + let patchy = 0.7 + 0.3 * fbm(p * 0.15, s + 13, 2); + self.layers[MEMBRANE][i] = (edge + 0.12 * inside) * patchy; + } + } + self.draw_mitochondria(random); + self.draw_golgi(random); + self.draw_vesicles(random); + self.draw_fragments(random); + } + + /// A point in the cytosol, nearer the nucleus more often than not. + fn cytosolic_point(&self, random: &mut Random) -> Vec2 { + for _ in 0..200 { + let a = random.between(0.0, TAU); + let r = self.rim(a) * random.between(0.15, 0.92).powf(0.8); + let p = self.centre + Vec2::new(a.cos(), a.sin()) * r; + if self.in_nucleus(p) > 1.08 { + return p; + } + } + self.centre + } + + /// Mitochondria: tubes a few micrometres long, wandering through the + /// cytosol, thickest around the nucleus. + fn draw_mitochondria(&mut self, random: &mut Random) { + for _ in 0..300 { + let mut p = self.cytosolic_point(random); + let mut heading = random.between(0.0, TAU); + let length = random.between(10.0, 42.0) as usize; + let brightness = random.between(0.6, 1.0); + for _ in 0..length { + heading += random.between(-0.35, 0.35); + let next = p + Vec2::new(heading.cos(), heading.sin()) * 1.4; + if self.depth(next).0 < 0.06 || self.in_nucleus(next) < 1.05 { + heading += 2.0; + continue; + } + p = next; + splat(&mut self.layers[MITOCHONDRIA], p, 1.5, brightness); + } + } + cap(&mut self.layers[MITOCHONDRIA], 1.3); + } + + /// The Golgi apparatus: curved stacks against one side of the nucleus. + fn draw_golgi(&mut self, random: &mut Random) { + let (c, axes, angle) = self.nucleus; + let side = (self.centre - c).y.atan2((self.centre - c).x) + PI; + for _ in 0..34 { + let a = side + random.between(-0.5, 0.5); + let out = random.between(1.12, 1.45); + let start = c + rotate(Vec2::new(a.cos() * axes.x, a.sin() * axes.y) * out, angle); + let along = Vec2::new(-a.sin(), a.cos()); + let length = random.between(6.0, 16.0); + let mut t = -length / 2.0; + while t < length / 2.0 { + let bend = 0.04 * t * t; + let p = start + rotate(along * t, angle) + (start - c).normalize_or_zero() * bend; + splat(&mut self.layers[GOLGI], p, 1.4, 0.8); + t += 1.0; + } + } + cap(&mut self.layers[GOLGI], 1.3); + } + + /// Vesicles: small bright points through the cytosol. + fn draw_vesicles(&mut self, random: &mut Random) { + for _ in 0..260 { + let p = self.cytosolic_point(random); + splat(&mut self.layers[VESICLES], p, 1.3, random.between(0.5, 1.0)); + } + cap(&mut self.layers[VESICLES], 1.2); + } + + /// The nucleus of an apoptotic cell, condensed and broken into round + /// pieces, what a section shows as karyorrhexis. + fn draw_fragments(&mut self, random: &mut Random) { + let (c, axes, angle) = self.nucleus; + for _ in 0..6 { + let a = random.between(0.0, TAU); + let d = random.between(0.0, 0.6); + let p = c + rotate(Vec2::new(a.cos() * axes.x, a.sin() * axes.y) * d, angle); + let r = random.between(0.05, 0.09) * self.radius; + let (x0, x1) = ( + (p.x - r * 1.5).max(0.0) as usize, + (p.x + r * 1.5).min(SIZE as f32 - 1.0) as usize, + ); + let (y0, y1) = ( + (p.y - r * 1.5).max(0.0) as usize, + (p.y + r * 1.5).min(SIZE as f32 - 1.0) as usize, + ); + for y in y0..=y1 { + for x in x0..=x1 { + let d = Vec2::new(x as f32, y as f32).distance(p); + let v = 1.4 * (1.0 - smooth(0.85 * r, r, d)); + let cell = &mut self.layers[FRAGMENTS][y * SIZE + x]; + *cell = cell.max(v); + } + } + } + } + + /// Where pixel `(x, y)` of the image is in the cell, as it is when + /// alive. + pub fn compartment(&self, x: f32, y: f32) -> Compartment { + let p = Vec2::new(x, y); + let (_, to_rim) = self.depth(p); + if to_rim < -2.5 { + return Compartment::Outside; + } + if to_rim < 4.0 { + return Compartment::Membrane; + } + if self.in_nucleus(p) < 1.0 { + let in_nucleolus = self.nucleoli.iter().any(|(c, r)| p.distance(*c) < *r); + return if in_nucleolus { + Compartment::Nucleolus + } else { + Compartment::Nucleus + }; + } + let at = |layer: usize| { + let (xi, yi) = (x as usize, y as usize); + if xi < SIZE && yi < SIZE { + self.layers[layer][yi * SIZE + xi] + } else { + 0.0 + } + }; + if at(GOLGI) > 0.45 { + Compartment::Golgi + } else if at(MITOCHONDRIA) > 0.5 { + Compartment::Mitochondrion + } else if at(VESICLES) > 0.45 { + Compartment::Vesicle + } else { + Compartment::Cytosol + } + } + + /// Paint the image the camera records: every channel, through the + /// cell's fate, with this frame's grain, into an sRGB RGBA buffer. + pub fn expose(&self, channels: &[Channel], fate: Fate, frame: u32, out: &mut [u8]) { + use rayon::prelude::*; + let warp = Warp::of(fate, self.centre); + out.par_chunks_mut(SIZE * 4) + .enumerate() + .for_each(|(y, row)| { + for x in 0..SIZE { + let p = Vec2::new(x as f32, y as f32); + let (q, fade) = warp.source(p); + // Light falls off towards the edges of the field, as it + // does through any objective. + let off = (p - Vec2::splat(SIZE as f32 / 2.0)).length() / SIZE as f32; + let field = 1.0 - 0.35 * off * off; + let mut colour = [0.006f32, 0.007, 0.012]; + for channel in channels { + if channel.amount <= 0.0 && channel.layers[FRAGMENTS] == 0.0 { + continue; + } + let mut signal = 0.0; + for (l, &w) in channel.layers.iter().enumerate() { + if w == 0.0 { + continue; + } + let mut v = self.sample(l, q); + if l == DNA { + v = warp.dna(v, self.sample(FRAGMENTS, q)); + } + signal += w * v; + } + let signal = signal * channel.amount * channel.gain * fade * field; + for (c, dye) in colour.iter_mut().zip(channel.colour) { + *c += signal * dye; + } + } + // The camera's grain: photon counts scatter as their square + // root, over a floor of read noise. + let seed = (y * SIZE + x) as u32 ^ frame.wrapping_mul(0x9E37_79B9); + let shot = hash(seed) - 0.5; + let read = hash(seed ^ 0x5bd1_e995) - 0.5; + let px = &mut row[x * 4..x * 4 + 4]; + for k in 0..3 { + let c = colour[k]; + let c = (c + shot * 0.09 * c.sqrt() + read * 0.012).max(0.0); + // A soft shoulder rather than a hard clip, as a display + // lookup table gives. + let c = 1.0 - (-1.6 * c).exp(); + px[k] = (srgb(c) * 255.0) as u8; + } + px[3] = 255; + } + }); + } + + /// Bilinear sample of a layer. + fn sample(&self, layer: usize, q: Vec2) -> f32 { + if q.x < 0.0 || q.y < 0.0 || q.x >= (SIZE - 1) as f32 || q.y >= (SIZE - 1) as f32 { + return 0.0; + } + let (x0, y0) = (q.x as usize, q.y as usize); + let (fx, fy) = (q.x - x0 as f32, q.y - y0 as f32); + let l = &self.layers[layer]; + let i = y0 * SIZE + x0; + let top = l[i] * (1.0 - fx) + l[i + 1] * fx; + let bottom = l[i + SIZE] * (1.0 - fx) + l[i + SIZE + 1] * fx; + top * (1.0 - fy) + bottom * fy + } +} + +/// How a dying cell's image is moved and faded. +struct Warp { + centre: Vec2, + fate: Fate, +} + +impl Warp { + fn of(fate: Fate, centre: Vec2) -> Self { + Self { centre, fate } + } + + /// Where pixel `p` of the image takes its light from in the living + /// cell, and how much of that light is left. + fn source(&self, p: Vec2) -> (Vec2, f32) { + let d = p - self.centre; + match self.fate { + Fate::Apoptotic(a) => { + // An apoptotic cell shrinks, and its membrane bulges into + // blebs that pinch off as the cell breaks up. + let angle = d.y.atan2(d.x); + let blebs = 0.13 + * a + * ((7.0 * angle + 1.3).sin().max(0.0).powi(3) + + 0.6 * (11.0 * angle + 0.4).sin().max(0.0).powi(4)); + let scale = (1.0 - 0.3 * a) * (1.0 + blebs); + (self.centre + d / scale, 1.0) + } + Fate::Necrotic(n) => { + // A necrotic cell swells as water rushes in, and its + // contents leak out and fade. + let scale = 1.0 + 0.2 * n; + (self.centre + d / scale, 1.0 - 0.75 * n) + } + _ => (p, 1.0), + } + } + + /// The DNA stain at a point: whole, broken into fragments, or fading. + fn dna(&self, whole: f32, fragments: f32) -> f32 { + match self.fate { + Fate::Apoptotic(a) => whole * (1.0 - a) + fragments * a, + Fate::Necrotic(n) => whole * (1.0 - 0.8 * n), + _ => whole, + } + } +} + +/// What a stain of `protein` lights up, by its name in a network file: the +/// compartments it lives in, given the levels it and its partners are at. +pub fn pattern(protein: &str, level: f32) -> [f32; LAYERS] { + let mut w = [0.0f32; LAYERS]; + match protein { + "egfr" => { + w[MEMBRANE] = 1.0; + w[VESICLES] = 0.3; + } + "ras" => { + w[MEMBRANE] = 1.0; + w[CYTOSOL] = 0.08; + } + "erk" => { + // Switched on, ERK goes into the nucleus: the more active, the + // more of it there. + let inside = 0.15 + 0.75 * level.clamp(0.0, 1.0); + w[CYTOSOL] = 1.0 - inside; + w[NUCLEOPLASM] = inside * 1.3; + } + "vegf" => { + w[GOLGI] = 1.0; + w[VESICLES] = 0.7; + } + "bcl2" => w[MITOCHONDRIA] = 1.0, + "bax" => { + // Inactive BAX floats in the cytosol; switched on, it gathers on + // the mitochondria. + let gathered = (level * 4.0).clamp(0.0, 1.0); + w[CYTOSOL] = 0.8 * (1.0 - gathered); + w[MITOCHONDRIA] = 1.3 * gathered; + } + "caspase" | "raf" | "mek" => w[CYTOSOL] = 1.0, + "cyclin_d" => { + w[NUCLEOPLASM] = 0.9; + w[CYTOSOL] = 0.2; + } + "hif1" | "p53" | "mdm2" | "p21" | "p27" | "rb" | "e2f" | "cyclin_e" => { + w[NUCLEOPLASM] = 1.0; + w[CYTOSOL] = 0.04; + } + _ => w[CYTOSOL] = 1.0, + } + w +} + +/// Where each protein of the fuller cell lives, in a sentence. +pub fn place_of(protein: &str) -> &'static str { + match protein { + "egfr" => "In the cell membrane, and in vesicles once taken back in.", + "ras" => "On the inner face of the cell membrane.", + "raf" | "mek" => "In the cytosol.", + "erk" => "In the cytosol; switched on, it moves into the nucleus.", + "hif1" => { + "Destroyed as soon as it is made while there is oxygen; without it, it builds up in the nucleus." + } + "vegf" => "Packed by the Golgi apparatus into vesicles, and secreted.", + "bcl2" => "In the outer membrane of the mitochondria.", + "bax" => "In the cytosol; switched on, it gathers on the mitochondria.", + "caspase" => "In the cytosol.", + "cyclin_d" => "Made in the cytosol, it works in the nucleus.", + _ => "In the nucleus.", + } +} + +/// The DNA stain, and the stains of the structure itself, which a +/// microscopist adds to see where things are. +pub fn dna_stain() -> [f32; LAYERS] { + let mut w = [0.0; LAYERS]; + w[DNA] = 1.0; + w +} + +/// The lens and the camera: a sharp image of each point spread over about +/// a pixel and a half, and a faint haze of light from above and below the +/// plane in focus. +fn optics(layer: &[f32]) -> Vec { + let sharp = blur(layer, 1.1); + let haze = blur(layer, 7.0); + sharp.iter().zip(&haze).map(|(s, h)| s + 0.14 * h).collect() +} + +/// A Gaussian blur, separable: rows, then columns. +fn blur(layer: &[f32], sigma: f32) -> Vec { + use rayon::prelude::*; + let reach = (3.0 * sigma).ceil() as isize; + let kernel: Vec = (-reach..=reach) + .map(|i| (-(i as f32).powi(2) / (2.0 * sigma * sigma)).exp()) + .collect(); + let total: f32 = kernel.iter().sum(); + let kernel: Vec = kernel.iter().map(|k| k / total).collect(); + let pass = |source: &[f32], horizontal: bool| -> Vec { + let mut out = vec![0.0; SIZE * SIZE]; + out.par_chunks_mut(SIZE).enumerate().for_each(|(a, line)| { + for (b, cell) in line.iter_mut().enumerate() { + let mut sum = 0.0; + for (k, w) in kernel.iter().enumerate() { + let o = b as isize + k as isize - reach; + if o < 0 || o >= SIZE as isize { + continue; + } + let o = o as usize; + sum += w * if horizontal { + source[a * SIZE + o] + } else { + source[o * SIZE + a] + }; + } + *cell = sum; + } + }); + out + }; + let rows = pass(layer, true); + // The second pass reads columns and writes them as rows: transpose + // back. + let columns = pass(&rows, false); + let mut out = vec![0.0; SIZE * SIZE]; + for a in 0..SIZE { + for b in 0..SIZE { + out[b * SIZE + a] = columns[a * SIZE + b]; + } + } + out +} + +/// Add a small Gaussian spot to a layer, keeping the brightest of what is +/// there and the spot. +fn splat(layer: &mut [f32], p: Vec2, sigma: f32, brightness: f32) { + let reach = (2.5 * sigma).ceil() as i32; + let (cx, cy) = (p.x.round() as i32, p.y.round() as i32); + for y in cy - reach..=cy + reach { + for x in cx - reach..=cx + reach { + if x < 0 || y < 0 || x >= SIZE as i32 || y >= SIZE as i32 { + continue; + } + let d2 = (x as f32 - p.x).powi(2) + (y as f32 - p.y).powi(2); + let v = brightness * (-d2 / (2.0 * sigma * sigma)).exp(); + let cell = &mut layer[y as usize * SIZE + x as usize]; + *cell = cell.max(v); + } + } +} + +fn cap(layer: &mut [f32], top: f32) { + for v in layer { + *v = v.min(top); + } +} + +fn rotate(v: Vec2, angle: f32) -> Vec2 { + let (s, c) = angle.sin_cos(); + Vec2::new(c * v.x - s * v.y, s * v.x + c * v.y) +} + +fn smooth(from: f32, to: f32, x: f32) -> f32 { + let t = ((x - from) / (to - from)).clamp(0.0, 1.0); + t * t * (3.0 - 2.0 * t) +} + +/// A linear value as sRGB. +fn srgb(c: f32) -> f32 { + if c <= 0.003_130_8 { + 12.92 * c + } else { + 1.055 * c.powf(1.0 / 2.4) - 0.055 + } +} + +/// A hash of an integer to a uniform value in [0, 1). +fn hash(mut x: u32) -> f32 { + x ^= x >> 16; + x = x.wrapping_mul(0x7feb_352d); + x ^= x >> 15; + x = x.wrapping_mul(0x846c_a68b); + x ^= x >> 16; + (x >> 8) as f32 / (1u32 << 24) as f32 +} + +/// Smooth noise in [0, 1): the hash on a grid, interpolated. +fn noise(p: Vec2, seed: u32) -> f32 { + let (x0, y0) = (p.x.floor(), p.y.floor()); + let (fx, fy) = (p.x - x0, p.y - y0); + let (fx, fy) = (fx * fx * (3.0 - 2.0 * fx), fy * fy * (3.0 - 2.0 * fy)); + let at = |dx: i32, dy: i32| { + let (x, y) = (x0 as i32 + dx, y0 as i32 + dy); + hash((x as u32).wrapping_mul(73_856_093) ^ (y as u32).wrapping_mul(19_349_663) ^ seed) + }; + let top = at(0, 0) * (1.0 - fx) + at(1, 0) * fx; + let bottom = at(0, 1) * (1.0 - fx) + at(1, 1) * fx; + top * (1.0 - fy) + bottom * fy +} + +/// Noise summed over octaves, each twice as fine and half as strong. +fn fbm(p: Vec2, seed: u32, octaves: u32) -> f32 { + let (mut sum, mut amplitude, mut scale, mut total) = (0.0, 1.0, 1.0, 0.0); + for o in 0..octaves { + sum += amplitude * noise(p * scale, seed.wrapping_add(o * 1013)); + total += amplitude; + amplitude *= 0.5; + scale *= 2.0; + } + sum / total +} + +/// The specimen's own random draws. +struct Random(u32); + +impl Random { + fn between(&mut self, low: f32, high: f32) -> f32 { + self.0 ^= self.0 << 13; + self.0 ^= self.0 >> 17; + self.0 ^= self.0 << 5; + low + (high - low) * ((self.0 >> 8) as f32 / (1u32 << 24) as f32) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn the_middle_of_the_nucleus_is_nucleus_and_the_corner_is_outside() { + let specimen = Specimen::new(7); + let (c, _, _) = specimen.nucleus; + // The nucleus's centre may fall in a nucleolus; a point beside it + // on the long axis is nucleoplasm or nucleolus, never cytosol. + assert!(matches!( + specimen.compartment(c.x, c.y), + Compartment::Nucleus | Compartment::Nucleolus + )); + assert_eq!(specimen.compartment(2.0, 2.0), Compartment::Outside); + } + + #[test] + fn a_protein_that_is_absent_leaves_the_image_dark() { + let specimen = Specimen::new(7); + let mut out = vec![0u8; SIZE * SIZE * 4]; + let channel = Channel { + layers: pattern("hif1", 0.0), + amount: 0.0, + colour: GREEN, + gain: 1.0, + }; + specimen.expose(&[channel], Fate::Cycling(0.0), 1, &mut out); + let brightest = out.chunks(4).map(|p| p[1]).max().unwrap_or(0); + assert!(brightest < 60, "only grain: {brightest}"); + let on = Channel { + amount: 0.8, + ..channel + }; + specimen.expose(&[on], Fate::Cycling(0.0), 1, &mut out); + let brightest = out.chunks(4).map(|p| p[1]).max().unwrap_or(0); + assert!(brightest > 150, "lit: {brightest}"); + } +} diff --git a/src/chrome.rs b/src/chrome.rs new file mode 100644 index 0000000..0d178e4 --- /dev/null +++ b/src/chrome.rs @@ -0,0 +1,624 @@ +//! The window's face: the story's bar at the top, the step's words and the +//! row of steps at the bottom, the panels between, the library when it is +//! open. It hears the user: the arrow keys and the buttons move through +//! the steps, drags turn proteins and move pictures, the wheel zooms, and a +//! click is recorded with what is under it. + +use std::time::Instant; + +use bevy::prelude::*; +use bevy_egui::{EguiContexts, EguiTextureHandle, egui}; + +use crate::cell::specimen::{self, Compartment}; +use crate::scene::{self, Scenes}; +use crate::stage::{self, Anchor, Kind, Stage}; +use crate::tissue::skin; +use crate::tools::{self, Views}; +use crate::world::Worlds; + +const BACK: egui::Color32 = egui::Color32::from_rgb(10, 12, 16); +const WORDS: egui::Color32 = egui::Color32::from_rgb(226, 229, 236); +const DIM: egui::Color32 = egui::Color32::from_rgb(140, 146, 160); + +/// The library's list, read from disk at most every two seconds. +#[derive(Default)] +pub struct Shelf { + read: Option, + stories: Vec<(String, String, usize, String)>, +} + +#[allow(clippy::too_many_arguments)] +pub fn chrome( + mut contexts: EguiContexts, + mut stage: ResMut, + mut scenes: ResMut, + views: Res, + mut worlds: ResMut, + cameras: Query<(&Camera, &GlobalTransform)>, + mut shelf: Local, +) -> Result { + let ctx = contexts.ctx_mut()?.clone(); + let steps = stage.story.as_ref().map_or(0, |s| s.steps.len()); + + // The arrow keys move through the steps. + if steps > 0 && !ctx.egui_wants_keyboard_input() { + let (next, back) = ctx.input(|i| { + ( + i.key_pressed(egui::Key::ArrowRight) || i.key_pressed(egui::Key::PageDown), + i.key_pressed(egui::Key::ArrowLeft) || i.key_pressed(egui::Key::PageUp), + ) + }); + if next && stage.step + 1 < steps { + stage.goto = Some(stage.step + 1); + } + if back && stage.step > 0 { + stage.goto = Some(stage.step - 1); + } + } + + // The space bar plays and pauses the films of the worlds shown. + if !ctx.egui_wants_keyboard_input() && ctx.input(|i| i.key_pressed(egui::Key::Space)) { + for scene in worlds.map.values_mut() { + if scene.playing && !scene.manual { + scene.playing = false; + } else if scene.clock >= scene.film.length() { + scene.replay(); + } else { + scene.playing = true; + scene.give_back(); + } + } + } + + let full = ctx.content_rect(); + let top = bar(&ctx, &mut stage, steps, full); + let bottom = words(&ctx, &mut stage, steps, full); + if stage.library { + library(&ctx, &mut stage, &mut shelf); + } + + let area = egui::Rect::from_min_max( + egui::pos2(full.left(), top), + egui::pos2(full.right(), bottom), + ) + .shrink(6.0); + stage.lay_out(area); + let painter = ctx.layer_painter(egui::LayerId::background()); + if stage.panels.is_empty() { + painter.text( + area.center(), + egui::Align2::CENTER_CENTER, + if steps > 0 { + "this step is empty" + } else { + "cellstage · waiting for the agent" + }, + egui::FontId::proportional(20.0), + egui::Color32::from_gray(140), + ); + return Ok(()); + } + // Textures for images not yet registered. + let mut textures = Vec::new(); + for (i, panel) in stage.panels.iter().enumerate() { + if panel.texture.is_none() + && let Some(image) = &panel.image + { + textures.push((i, image.clone())); + } + } + for (i, image) in textures { + let id = contexts.add_image(EguiTextureHandle::Strong(image)); + stage.panels[i].texture = Some(id); + } + let mut events = Vec::new(); + egui::Area::new(egui::Id::new("stage")) + .fixed_pos(egui::pos2(0.0, 0.0)) + .order(egui::Order::Background) + .show(&ctx, |ui| { + for panel in stage.panels.iter_mut() { + let content = panel.content(); + let solid = !matches!(panel.kind, Kind::Protein | Kind::World); + stage::frame(ui.painter(), panel, solid); + let size = match panel.kind { + Kind::Cell => (specimen::SIZE as f32, specimen::SIZE as f32), + Kind::Skin => (skin::WIDTH as f32, skin::HEIGHT as f32), + _ => (1.0, 1.0), + }; + let response = ui.interact( + content, + ui.id().with(&panel.id), + egui::Sense::click_and_drag(), + ); + let scroll = if response.hovered() { + ui.input(|i| i.smooth_scroll_delta.y) + } else { + 0.0 + }; + let image_rect = stage::image_rect(content, size, panel.zoom, panel.pan); + let clipped = ui.painter().with_clip_rect(content); + let whole = egui::Rect::from_min_max(egui::pos2(0.0, 0.0), egui::pos2(1.0, 1.0)); + if let Some(texture) = panel.texture { + match panel.kind { + Kind::Cell | Kind::Skin => { + clipped.image(texture, image_rect, whole, egui::Color32::WHITE); + scale_bar(&clipped, panel.kind, image_rect, content, size.0); + } + _ => {} + } + } + match panel.kind { + Kind::Protein => { + if let Some(scene) = scenes.map.get_mut(&panel.id) { + if response.dragged() { + let d = response.drag_delta(); + scene.orbit.turn(Vec2::new(d.x, d.y)); + } + if scroll != 0.0 { + scene.orbit.zoom(scroll / 40.0); + } + } + } + Kind::World => { + if let Some(scene) = worlds.map.get_mut(&panel.id) { + if response.dragged() { + let d = response.drag_delta(); + scene.take(); + scene.eye.turn(Vec2::new(d.x, d.y)); + } + if scroll != 0.0 { + scene.take(); + scene.eye.zoom(scroll / 40.0); + } + } + } + Kind::Cell | Kind::Skin => { + if scroll != 0.0 { + panel.zoom = (panel.zoom * (1.0 + scroll * 0.002)).clamp(1.0, 8.0); + } + if response.dragged() { + let d = response.drag_delta(); + panel.pan -= + egui::vec2(d.x / image_rect.width(), d.y / image_rect.height()); + } + let limit = 0.5 - 0.5 / panel.zoom; + panel.pan = panel + .pan + .clamp(egui::Vec2::splat(-limit), egui::Vec2::splat(limit)); + } + Kind::Empty => {} + } + if response.clicked() + && let Some(pointer) = response.interact_pointer_pos() + { + let fx = (pointer.x - content.left()) / content.width(); + let fy = (pointer.y - content.top()) / content.height(); + let p = image_point(image_rect, pointer, size); + let what = match panel.kind { + Kind::Protein => scenes.map.get(&panel.id).and_then(|scene| { + let (camera, eye) = cameras.get(scene.camera).ok()?; + // Bevy's viewport coordinates start at the window's + // corner, not the viewport's, as egui's do. + let ray = camera + .viewport_to_world(eye, Vec2::new(pointer.x, pointer.y)) + .ok()?; + scene + .pick(ray.origin, *ray.direction) + .map(|a| scene::describe(a, &scene.look, scene.t)) + }), + Kind::Cell => views.cells.get(&panel.id).map(|v| { + let c = v.specimen.compartment(p.x, p.y); + if c == Compartment::Outside { + c.name().to_owned() + } else { + format!("{}: {}", c.name(), c.what()) + } + }), + Kind::Skin => views.skins.get(&panel.id).map(|v| { + let r = v.section.region(p.x, p.y); + format!("{}: {}", r.name(), r.what()) + }), + Kind::World => worlds.map.get(&panel.id).and_then(|scene| { + let (camera, eye) = cameras.get(scene.camera).ok()?; + let ray = camera + .viewport_to_world(eye, Vec2::new(pointer.x, pointer.y)) + .ok()?; + scene.pick(ray.origin, *ray.direction) + }), + Kind::Empty => None, + }; + let what = what.unwrap_or_else(|| "nothing in particular".to_owned()); + events.push(format!( + "In panel {} (\"{}\"), at {:.2}, {:.2} of its width and height: {what}", + panel.id, panel.title, fx, fy + )); + ui.painter().circle_stroke( + pointer, + 10.0, + egui::Stroke::new(2.0, egui::Color32::from_rgb(255, 236, 160)), + ); + } + // The agent's notes, each beside what it points at. + let note_painter = ui.painter().with_clip_rect(panel.rect); + let mut taken: Vec = Vec::new(); + for n in &panel.notes { + let target = n.target.as_ref().and_then(|t| match t { + Anchor::Fraction(x, y) => Some( + content.min + egui::vec2(x * content.width(), y * content.height()), + ), + Anchor::Residue(chain, number) => { + scenes.map.get(&panel.id).and_then(|scene| { + let chain = (*chain != ' ').then_some(*chain); + let atom = scene.residue(chain, *number)?; + let (camera, eye) = cameras.get(scene.camera).ok()?; + let p = camera.world_to_viewport(eye, atom.at(scene.t)).ok()?; + Some(egui::pos2(p.x, p.y)) + }) + } + Anchor::Part(name) if panel.kind == Kind::World => { + worlds.map.get(&panel.id).and_then(|scene| { + let p = scene.locate(name)?; + let (camera, eye) = cameras.get(scene.camera).ok()?; + let p = camera.world_to_viewport(eye, p).ok()?; + let p = egui::pos2(p.x, p.y); + content.contains(p).then_some(p) + }) + } + Anchor::Part(name) => { + let at = match panel.kind { + Kind::Skin => views.skins.get(&panel.id).and_then(|v| { + v.places.iter().find(|(n, _)| n == name).map(|(_, p)| *p) + }), + Kind::Cell => views.cells.get(&panel.id).and_then(|v| { + v.places.iter().find(|(n, _)| n == name).map(|(_, p)| *p) + }), + _ => None, + }?; + Some(egui::pos2( + image_rect.left() + at.0 / size.0 * image_rect.width(), + image_rect.top() + at.1 / size.1 * image_rect.height(), + )) + } + }); + if n.target.is_some() && target.is_none() { + // What it points at is out of sight. + continue; + } + let rect = match (n.label, target) { + (Some((x, y)), _) => stage::label_at( + ¬e_painter, + &n.text, + content.min + egui::vec2(x * content.width(), y * content.height()), + ), + (None, Some(t)) => { + stage::place_label(¬e_painter, &n.text, t, content, &taken) + } + (None, None) => continue, + }; + taken.push(rect); + stage::note(¬e_painter, rect, &n.text, target); + } + // A protein seen in two states gets a slider between them. + if let Some(scene) = scenes.map.get_mut(&panel.id) + && scene.model.moves + { + let bar = egui::Rect::from_min_size( + content.left_bottom() + egui::vec2(10.0, -34.0), + egui::vec2(content.width().min(420.0), 26.0), + ); + ui.scope_builder(egui::UiBuilder::new().max_rect(bar), |ui| { + ui.horizontal(|ui| { + if ui + .button(if scene.playing { "pause" } else { "play" }) + .clicked() + { + scene.playing = !scene.playing; + } + ui.label("first"); + ui.add(egui::Slider::new(&mut scene.t, 0.0..=1.0).show_value(false)); + ui.label("second"); + }); + }); + } + if let Some(scene) = worlds.map.get_mut(&panel.id) { + film_controls(ui, scene, content); + } + } + }); + stage.events.extend(events); + Ok(()) +} + +/// Height of the bar at the top, in points. +const BAR: f32 = 40.0; + +/// The bar at the top: the story, the step, the buttons. Returns where it +/// ends. +fn bar(ctx: &egui::Context, stage: &mut Stage, steps: usize, full: egui::Rect) -> f32 { + let rect = egui::Rect::from_min_size(full.min, egui::vec2(full.width(), BAR)); + ctx.layer_painter(egui::LayerId::background()) + .rect_filled(rect, 0.0, BACK); + egui::Area::new(egui::Id::new("story")) + .fixed_pos(rect.min + egui::vec2(12.0, 8.0)) + .order(egui::Order::Middle) + .show(ctx, |ui| { + ui.horizontal(|ui| { + let title = stage + .story + .as_ref() + .map_or("cellstage".to_owned(), |s| s.title.clone()); + ui.label(egui::RichText::new(title).size(18.0).strong().color(WORDS)); + if let Some(step) = stage.story.as_ref().and_then(|s| s.steps.get(stage.step)) { + ui.add_space(12.0); + ui.label( + egui::RichText::new(format!( + "step {} of {} · {}", + stage.step + 1, + steps, + step.title + )) + .size(15.0) + .color(DIM), + ); + } + }); + }); + egui::Area::new(egui::Id::new("buttons")) + .anchor(egui::Align2::RIGHT_TOP, egui::vec2(-12.0, full.top() + 7.0)) + .order(egui::Order::Middle) + .show(ctx, |ui| { + ui.horizontal(|ui| { + if steps > 0 { + ui.label( + egui::RichText::new("arrow keys to move") + .size(12.0) + .color(DIM), + ); + if ui + .add_enabled(stage.step > 0, egui::Button::new("◀ back")) + .clicked() + { + stage.goto = Some(stage.step - 1); + } + if ui + .add_enabled(stage.step + 1 < steps, egui::Button::new("next ▶")) + .clicked() + { + stage.goto = Some(stage.step + 1); + } + ui.add_space(10.0); + } + if ui + .selectable_label(stage.library, "library") + .on_hover_text("every story told so far") + .clicked() + { + stage.library = !stage.library; + } + }); + }); + rect.bottom() +} + +/// The bottom: what the step says, and the row of steps. Returns where it +/// begins. +fn words(ctx: &egui::Context, stage: &mut Stage, steps: usize, full: egui::Rect) -> f32 { + let Some(story) = stage.story.as_ref() else { + return full.bottom(); + }; + let narration = story + .steps + .get(stage.step) + .map(|s| s.narration.clone()) + .unwrap_or_default(); + let titles: Vec = story.steps.iter().map(|s| s.title.clone()).collect(); + let width = full.width() - 32.0; + let painter = ctx.layer_painter(egui::LayerId::background()); + let text_height = if narration.is_empty() { + 0.0 + } else { + painter + .layout( + narration.clone(), + egui::FontId::proportional(17.0), + WORDS, + width, + ) + .size() + .y + .min(150.0) + + 8.0 + }; + let row = if steps > 1 { 30.0 } else { 0.0 }; + let height = text_height + row + 14.0; + let rect = egui::Rect::from_min_max(egui::pos2(full.left(), full.bottom() - height), full.max); + painter.rect_filled(rect, 0.0, BACK); + egui::Area::new(egui::Id::new("words")) + .fixed_pos(rect.min + egui::vec2(16.0, 8.0)) + .order(egui::Order::Middle) + .show(ctx, |ui| { + ui.set_width(width); + if !narration.is_empty() { + egui::ScrollArea::vertical() + .max_height(150.0) + .show(ui, |ui| { + ui.add( + egui::Label::new( + egui::RichText::new(&narration).size(17.0).color(WORDS), + ) + .wrap(), + ); + }); + ui.add_space(4.0); + } + if steps > 1 { + ui.horizontal_wrapped(|ui| { + for (k, title) in titles.iter().enumerate() { + if ui + .selectable_label(k == stage.step, format!(" {} ", k + 1)) + .on_hover_text(title) + .clicked() + { + stage.goto = Some(k); + } + } + }); + } + }); + rect.top() +} + +/// The library: every story told so far, to open again. +fn library(ctx: &egui::Context, stage: &mut Stage, shelf: &mut Shelf) { + if shelf.read.is_none_or(|t| t.elapsed().as_secs_f32() > 2.0) { + shelf.stories = tools::library_list(); + shelf.read = Some(Instant::now()); + } + let mut open = true; + egui::Window::new("Library") + .open(&mut open) + .default_width(560.0) + .default_pos(egui::pos2(80.0, 80.0)) + .show(ctx, |ui| { + if shelf.stories.is_empty() { + ui.label("No story yet. Ask the agent to tell one: it is kept here as it is told."); + } + egui::ScrollArea::vertical() + .max_height(480.0) + .show(ui, |ui| { + for (id, title, steps, changed) in &shelf.stories { + ui.horizontal(|ui| { + if ui.button("open").clicked() { + stage.open = Some(id.clone()); + stage.library = false; + } + ui.label(egui::RichText::new(title).strong()); + ui.label( + egui::RichText::new(format!("{steps} steps · {changed}")) + .color(DIM), + ); + }); + } + }); + }); + if !open { + stage.library = false; + } +} + +/// A scale bar, as on every micrograph. +fn scale_bar( + painter: &egui::Painter, + kind: Kind, + image_rect: egui::Rect, + content: egui::Rect, + width: f32, +) { + let (micrometres, per_pixel, ink) = match kind { + Kind::Cell => (10.0, specimen::MICROMETRES_PER_PIXEL, egui::Color32::WHITE), + _ => ( + 100.0, + skin::MICROMETRES_PER_PIXEL, + egui::Color32::from_gray(25), + ), + }; + let length = micrometres / per_pixel * image_rect.width() / width; + let inside = image_rect.intersect(content); + let corner = inside.right_bottom() + egui::vec2(-16.0 - length, -16.0); + painter.line_segment( + [corner, corner + egui::vec2(length, 0.0)], + egui::Stroke::new(4.0, ink), + ); + painter.text( + corner + egui::vec2(length / 2.0, -5.0), + egui::Align2::CENTER_BOTTOM, + format!("{micrometres:.0} µm"), + egui::FontId::proportional(12.0), + ink, + ); +} + +/// The point of an image under a point of the screen, in the image's units. +fn image_point(rect: egui::Rect, pointer: egui::Pos2, size: (f32, f32)) -> Vec2 { + Vec2::new( + (pointer.x - rect.left()) / rect.width() * size.0, + (pointer.y - rect.top()) / rect.height() * size.1, + ) +} + +/// A world's film: the words said over it, large, near the bottom; the +/// world's clock; and the buttons to play it again, pause it and move +/// through it. +fn film_controls(ui: &mut egui::Ui, scene: &mut crate::world::WorldScene, content: egui::Rect) { + let painter = ui.painter().with_clip_rect(content); + if let Some((words, shown)) = &scene.say + && *shown > 0.01 + { + let alpha = (shown * 255.0) as u8; + let galley = painter.layout( + words.clone(), + egui::FontId::proportional(24.0), + egui::Color32::from_rgba_unmultiplied(246, 244, 238, alpha), + (content.width() - 120.0).min(1100.0), + ); + let at = egui::pos2( + content.center().x - galley.size().x * 0.5, + content.bottom() - 70.0 - galley.size().y, + ); + painter.rect_filled( + egui::Rect::from_min_size(at, galley.size()).expand2(egui::vec2(18.0, 10.0)), + 8.0, + egui::Color32::from_rgba_unmultiplied(0, 0, 0, (shown * 150.0) as u8), + ); + painter.galley(at, galley, egui::Color32::WHITE); + } + if let Some(label) = scene.clock_label() { + painter.text( + content.right_top() + egui::vec2(-16.0, 14.0), + egui::Align2::RIGHT_TOP, + label, + egui::FontId::proportional(18.0), + egui::Color32::from_rgb(255, 214, 140), + ); + } + if scene.film.shots.is_empty() { + return; + } + let bar = egui::Rect::from_min_size( + content.left_bottom() + egui::vec2(10.0, -36.0), + egui::vec2(content.width().min(460.0), 28.0), + ); + ui.painter().rect_filled( + bar.expand(3.0), + 5.0, + egui::Color32::from_rgba_unmultiplied(10, 12, 16, 170), + ); + ui.scope_builder(egui::UiBuilder::new().max_rect(bar), |ui| { + ui.horizontal(|ui| { + if ui.button("replay").clicked() { + scene.replay(); + } + let playing = scene.playing && !scene.manual; + if ui.button(if playing { "pause" } else { "play" }).clicked() { + if playing { + scene.playing = false; + } else { + if scene.clock >= scene.film.length() { + scene.replay(); + } + scene.playing = true; + scene.give_back(); + } + } + let length = scene.film.length(); + let mut at = scene.clock; + if ui + .add(egui::Slider::new(&mut at, 0.0..=length).show_value(false)) + .changed() + { + scene.clock = at; + scene.give_back(); + } + }); + }); +} diff --git a/src/main.rs b/src/main.rs new file mode 100644 index 0000000..eb00b66 --- /dev/null +++ b/src/main.rs @@ -0,0 +1,428 @@ +//! cellstage: a window an agent tells biology on, step by step. +//! +//! The program is a Model Context Protocol server over standard input and +//! output, and a window. An agent connected to it, in a terminal or any +//! client, tells a story in steps the user moves through with the arrow +//! keys. Each step splits the window into panels and shows in them worlds +//! built in three dimensions that the agent films; proteins at their +//! measured atomic structure or as AlphaFold predicts them; a cell under a +//! fluorescence microscope whose network cellweave runs live; stained +//! tissue sections drawn from histology. The window makes everything it +//! shows: it fetches no pictures from anywhere, and the agent draws +//! nothing. Every story is kept in a library on disk, to be told again at +//! once. The user turns and zooms what is shown, clicks on it, and the +//! agent hears what was clicked. +//! +//! Every panel says what it is: a measured or a predicted structure, a +//! simulation, an illustration. + +#![deny(unsafe_code)] +// The tools' descriptions are one long json! literal. +#![recursion_limit = "512"] + +mod cell; +mod chrome; +mod mcp; +mod protein; +mod scene; +mod sources; +mod stage; +mod story; +mod tissue; +mod tools; +mod world; + +use std::sync::Mutex; +use std::sync::mpsc::{Receiver, Sender, channel}; +use std::time::Duration; + +use bevy::asset::RenderAssetUsages; +use bevy::camera::CameraOutputMode; +use bevy::camera::visibility::RenderLayers; +use bevy::prelude::*; +use bevy::render::render_resource::{BlendState, Extent3d, TextureDimension, TextureFormat}; +use bevy::render::view::screenshot::{Screenshot, ScreenshotCaptured}; +use bevy::window::{ExitCondition, PrimaryWindow, WindowCloseRequested}; +use bevy::winit::{EventLoopProxyWrapper, UpdateMode, WinitSettings, WinitUserEvent}; +use bevy_egui::{EguiGlobalSettings, EguiPlugin, EguiPrimaryContextPass, PrimaryEguiContext}; + +use crate::cell::specimen::{self, Channel}; +use crate::mcp::{Message, Reply}; +use crate::scene::Scenes; +use crate::stage::Stage; +use crate::story::Story; +use crate::tools::{Mode, Views}; + +/// Tool calls from the protocol's thread. +#[derive(Resource)] +struct Inbox(Mutex>); + +/// The dyes of the cell's three protein channels. +const DYES: [[f32; 3]; 3] = [specimen::GREEN, specimen::RED, specimen::MAGENTA]; + +fn main() -> anyhow::Result<()> { + let (to_window, inbox) = channel(); + world::warm(); + let mut app = App::new(); + app.add_plugins(DefaultPlugins.set(WindowPlugin { + primary_window: Some(Window { + title: "cellstage".to_owned(), + resolution: (1600, 960).into(), + // Shown when the agent first shows something, not when it + // connects. + visible: false, + ..default() + }), + exit_condition: ExitCondition::DontExit, + close_when_requested: false, + ..default() + })) + .add_plugins(EguiPlugin::default()) + .add_plugins((world::glow::GlowPlugin, world::surface::SurfacePlugin)) + // Hidden until the agent first shows something, so asleep until then. + .insert_resource(asleep()) + .insert_resource(ClearColor(scene::BACKGROUND)) + .insert_resource(Inbox(Mutex::new(inbox))) + .insert_resource(Stage::default()) + .insert_resource(Scenes::default()) + .insert_resource(world::Worlds::default()) + .insert_resource(Views::default()) + .insert_resource(GlobalAmbientLight { + color: Color::srgb(0.75, 0.8, 1.0), + brightness: 120.0, + ..default() + }) + .add_systems(Startup, setup) + .add_systems( + Update, + ( + bridge, + live_cells, + scene::place, + world::run, + hide_on_close, + pace, + ) + .chain(), + ) + .add_systems(EguiPrimaryContextPass, chrome::chrome); + // The loop sleeps while the window is hidden: each message from the + // agent wakes it. + let proxy = (*app.world().resource::()).clone(); + std::thread::spawn(move || { + mcp::serve(to_window, move || { + let _ = proxy.send_event(WinitUserEvent::WakeUp); + }) + }); + app.run(); + Ok(()) +} + +/// A camera that clears the whole window, and one that draws the panels' +/// frames and 2D content over everything. +fn setup(mut commands: Commands, mut egui: ResMut) { + egui.auto_create_primary_context = false; + commands.spawn(( + Camera3d::default(), + Camera { + order: 0, + clear_color: ClearColorConfig::Custom(scene::BACKGROUND), + ..default() + }, + bevy::camera::Hdr, + bevy::core_pipeline::tonemapping::Tonemapping::AcesFitted, + Msaa::Off, + RenderLayers::none(), + )); + commands.spawn(( + PrimaryEguiContext, + Camera2d, + // The default needs lookup tables this build leaves out; the panels + // are drawn in plain sRGB anyway. + bevy::core_pipeline::tonemapping::Tonemapping::None, + RenderLayers::none(), + Msaa::Off, + Camera { + order: 100, + output_mode: CameraOutputMode::Write { + blend_state: Some(BlendState::ALPHA_BLENDING), + clear_color: ClearColorConfig::None, + }, + clear_color: ClearColorConfig::Custom(Color::NONE), + ..default() + }, + )); +} + +/// Hide the window when the user closes it: the agent may show more. +fn hide_on_close( + mut closed: MessageReader, + mut windows: Query<&mut Window, With>, + mut stage: ResMut, +) { + if closed.read().count() > 0 + && let Ok(mut window) = windows.single_mut() + { + window.visible = false; + stage.shown = false; + } +} + +/// Run the loop flat out while the window is shown, and sleep while it is +/// hidden: drawing a window nobody sees, as fast as the loop turns, kept +/// whole cores busy for nothing. +fn pace(stage: Res, mut settings: ResMut) { + let wanted = if stage.shown { + WinitSettings::game() + } else { + asleep() + }; + if settings.focused_mode != wanted.focused_mode + || settings.unfocused_mode != wanted.unfocused_mode + { + *settings = wanted; + } +} + +/// Wait for an event, however long: a message from the agent, or the +/// window shown again. +fn asleep() -> WinitSettings { + let wait = UpdateMode::reactive_low_power(Duration::MAX); + WinitSettings { + focused_mode: wait, + unfocused_mode: wait, + } +} + +/// Do every tool call that has arrived, then what the user asked of the +/// window, and keep the story if it changed. +fn bridge(world: &mut World) { + let calls: Vec = { + let inbox = world.resource::(); + let Ok(rx) = inbox.0.lock() else { return }; + rx.try_iter().collect() + }; + for message in calls { + match message { + Message::Quit => { + world.write_message(AppExit::Success); + } + Message::Call(call) => match call.tool.as_str() { + "screenshot" => screenshot(world, call.reply), + _ => { + let reply = match tools::handle(world, &call.tool, &call.args, Mode::Record) { + Ok(text) => Reply::text(text), + Err(e) => Reply::error(e), + }; + let _ = call.reply.send(reply); + } + }, + } + } + let (goto, open) = { + let mut stage = world.resource_mut::(); + (stage.goto.take(), stage.open.take()) + }; + if let Some(id) = open { + match Story::load(&id) { + Ok(story) => { + let title = story.title.clone(); + { + let mut stage = world.resource_mut::(); + stage.story = Some(story); + stage.step = 0; + } + tools::show_step(world, 0); + world.resource_mut::().events.push(format!( + "The user opened the story \"{title}\" ({id}) from the library." + )); + } + Err(e) => warn!("{e}"), + } + } + if let Some(n) = goto { + tools::show_step(world, n); + let mut stage = world.resource_mut::(); + let said = stage.story.as_ref().map(|s| { + format!( + "The user moved to step {} of {}, \"{}\".", + n + 1, + s.steps.len(), + s.steps.get(n).map_or("", |t| t.title.as_str()) + ) + }); + if let Some(said) = said { + stage.events.push(said); + } + } + tools::save(world); + // The window says which story it tells. + let title = world + .resource::() + .story + .as_ref() + .map_or("cellstage".to_owned(), |s| { + format!("cellstage · {}", s.title) + }); + let mut windows = world.query_filtered::<&mut Window, With>(); + if let Ok(mut window) = windows.single_mut(world) + && window.title != title + { + window.title = title; + } +} + +/// A picture of the window, sent back as a PNG once the renderer has +/// taken it. +fn screenshot(world: &mut World, reply: Sender) { + if !world.resource::().shown { + let _ = reply.send(Reply::error( + "the window is not shown yet: show something first", + )); + return; + } + let reply = Mutex::new(Some(reply)); + world + .spawn(Screenshot::primary_window()) + .observe(move |captured: On| { + let Some(reply) = reply.lock().ok().and_then(|mut r| r.take()) else { + return; + }; + let answer = match png(&captured.image) { + Ok(png) => Reply { + text: "The window as it is now.".to_owned(), + image: Some(png), + error: false, + }, + Err(e) => Reply::error(format!("could not encode the picture: {e}")), + }; + let _ = reply.send(answer); + }); +} + +/// Pixels as a PNG, RGB or RGBA by `channels`. +fn encode(pixels: &[u8], w: u32, h: u32, channels: usize) -> anyhow::Result> { + let mut out = Vec::new(); + { + let mut encoder = png::Encoder::new(&mut out, w, h); + encoder.set_color(if channels == 4 { + png::ColorType::Rgba + } else { + png::ColorType::Rgb + }); + encoder.set_depth(png::BitDepth::Eight); + let mut writer = encoder.write_header()?; + writer.write_image_data(pixels)?; + } + Ok(out) +} + +/// An image the renderer captured, as a PNG, halved if it is large. +fn png(image: &Image) -> anyhow::Result> { + let (w, h) = (image.width() as usize, image.height() as usize); + let data = image + .data + .as_ref() + .ok_or_else(|| anyhow::anyhow!("no pixels"))?; + let bgra = matches!( + image.texture_descriptor.format, + TextureFormat::Bgra8UnormSrgb | TextureFormat::Bgra8Unorm + ); + let halve = w > 1400; + let (ow, oh) = if halve { (w / 2, h / 2) } else { (w, h) }; + let mut rgb = Vec::with_capacity(ow * oh * 3); + for y in 0..oh { + for x in 0..ow { + let mut sum = [0u32; 3]; + let samples: &[(usize, usize)] = if halve { + &[(0, 0), (1, 0), (0, 1), (1, 1)] + } else { + &[(0, 0)] + }; + for (dx, dy) in samples { + let (sx, sy) = if halve { + (x * 2 + dx, y * 2 + dy) + } else { + (x, y) + }; + let i = (sy * w + sx) * 4; + let (r, g, b) = if bgra { + (data[i + 2], data[i + 1], data[i]) + } else { + (data[i], data[i + 1], data[i + 2]) + }; + sum[0] += u32::from(r); + sum[1] += u32::from(g); + sum[2] += u32::from(b); + } + let n = samples.len() as u32; + rgb.extend_from_slice(&[(sum[0] / n) as u8, (sum[1] / n) as u8, (sum[2] / n) as u8]); + } + } + encode(&rgb, ow as u32, oh as u32, 3) +} + +/// A black image of a size, kept on the CPU to be written into. +pub fn blank(width: usize, height: usize) -> Image { + Image::new_fill( + Extent3d { + width: width as u32, + height: height as u32, + depth_or_array_layers: 1, + }, + TextureDimension::D2, + &[0, 0, 0, 255], + TextureFormat::Rgba8UnormSrgb, + RenderAssetUsages::MAIN_WORLD | RenderAssetUsages::RENDER_WORLD, + ) +} + +/// The cells live: each running dish steps twice a second, and its picture +/// is exposed again some fifteen times a second. +fn live_cells(time: Res