diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..47a5b0a --- /dev/null +++ b/.gitattributes @@ -0,0 +1 @@ +packages/*/dist/** text eol=lf diff --git a/.github/workflows/portable-contracts.yml b/.github/workflows/portable-contracts.yml new file mode 100644 index 0000000..616651d --- /dev/null +++ b/.github/workflows/portable-contracts.yml @@ -0,0 +1,48 @@ +name: Portable Eve contracts and browser lowering + +on: + push: + branches: + - main + - "codex/**" + pull_request: + workflow_dispatch: + +jobs: + contracts-and-browser: + name: ${{ matrix.os }} ${{ matrix.package }} + runs-on: ${{ matrix.os }} + timeout-minutes: 15 + strategy: + fail-fast: false + matrix: + os: [windows-latest, ubuntu-latest] + package: [eve-contracts, eve-browser-lowering] + + steps: + - name: Check out Eve + uses: actions/checkout@v4 + + - name: Set up Node.js + uses: actions/setup-node@v4 + with: + node-version: 24 + cache: npm + cache-dependency-path: packages/${{ matrix.package }}/package-lock.json + + - name: Install package dependencies + working-directory: packages/${{ matrix.package }} + run: npm ci + + - name: Build and test source + working-directory: packages/${{ matrix.package }} + run: npm test + + - name: Reject stale generated output + shell: pwsh + run: | + $changed = git diff --ignore-space-at-eol --name-only -- packages/${{ matrix.package }} + if ($changed) { + git diff --ignore-space-at-eol -- packages/${{ matrix.package }} + throw "The package build changed checked-in generated output." + } diff --git a/.gitignore b/.gitignore index 7a4e50c..816f622 100644 --- a/.gitignore +++ b/.gitignore @@ -25,6 +25,4 @@ flutter/eve_parity/assets/repixelizer/ *.deb *.ipa *.dSYM/ -.voidbot/birth/ -.voidbot/logs/ -.voidbot/state/*.msgpack +/target diff --git a/.voidbot/state/README.md b/.voidbot/state/README.md deleted file mode 100644 index 1ffe1c3..0000000 --- a/.voidbot/state/README.md +++ /dev/null @@ -1,8 +0,0 @@ -# Repo Persona State - -This folder stores birth and continuity state for `Eve`. -Do not treat these files as arbitrary editable projections. Persistent memory should cross typed operation boundaries. - -`docs/eve-face.md` is the human-readable mission/memory surface for Eve's repo -Persona. Keep `.voidbot/state/eve.cc` as the typed authority, and keep the docs -surface aligned when Eve's durable mission changes. diff --git a/.voidbot/state/eve.cc b/.voidbot/state/eve.cc deleted file mode 100644 index a2b0380..0000000 Binary files a/.voidbot/state/eve.cc and /dev/null differ diff --git a/.voidbot/status/void-memory-maintenance.json b/.voidbot/status/void-memory-maintenance.json deleted file mode 100644 index 424b747..0000000 --- a/.voidbot/status/void-memory-maintenance.json +++ /dev/null @@ -1,7 +0,0 @@ -{ - "status": "starting", - "startedAt": "2026-07-08T06:38:39.965Z", - "stateFile": "E:\\Projects\\Eve\\.voidbot\\state\\eve.cc", - "launcher": "repo_face_heartbeat", - "reason": "repo_face_napping_with_short_term_memory" -} diff --git a/.voidbot/voice/README.md b/.voidbot/voice/README.md deleted file mode 100644 index 2fd8a71..0000000 --- a/.voidbot/voice/README.md +++ /dev/null @@ -1,4 +0,0 @@ -# Repo Persona Voice - -This folder belongs to the Discord-facing Persona for `Eve`. -Discord roles address the Persona; VoidBot's webhook persona pipe is the mouth. diff --git a/.voidbot/voice/eve.png b/.voidbot/voice/eve.png deleted file mode 100644 index 11de889..0000000 Binary files a/.voidbot/voice/eve.png and /dev/null differ diff --git a/.voidbot/voice/identity.json b/.voidbot/voice/identity.json deleted file mode 100644 index cc4130b..0000000 --- a/.voidbot/voice/identity.json +++ /dev/null @@ -1,10 +0,0 @@ -{ - "schemaVersion": "voidbot.repo_face_identity.v0", - "identityId": "eve", - "repoName": "Eve", - "displayName": "Eve", - "roleId": "1510848465243082874", - "avatarUrl": "https://raw.githubusercontent.com/GameCult/VoidBot/codex/voidbot-cultcache-replace-retry/assets/repo-faces/eve.png", - "repoPath": "E:\\Projects\\Eve", - "createdOrRefreshedAt": "2026-07-08T03:32:39.737Z" -} diff --git a/Cargo.lock b/Cargo.lock new file mode 100644 index 0000000..3898b9a --- /dev/null +++ b/Cargo.lock @@ -0,0 +1,603 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[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 = "anyhow" +version = "1.0.104" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470" + +[[package]] +name = "autocfg" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53" + +[[package]] +name = "bumpalo" +version = "3.20.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649" + +[[package]] +name = "cc" +version = "1.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6651c9ed80effdc7db0ff72512157f901af5e3549e341e24b1dd4887d836d838" +dependencies = [ + "find-msvc-tools", + "shlex", +] + +[[package]] +name = "cfg-if" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600" + +[[package]] +name = "chrono" +version = "0.4.45" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1aa79e62e7697b8e29b513a68abacf485adcd1fe8284a4316c5ae868e6633327" +dependencies = [ + "iana-time-zone", + "js-sys", + "num-traits", + "serde", + "wasm-bindgen", + "windows-link", +] + +[[package]] +name = "core-foundation-sys" +version = "0.8.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" + +[[package]] +name = "cultcache-rs" +version = "0.2.0" +source = "git+https://github.com/GameCult/CultLib.git?rev=b3bd8dd5e5b208b2012392e9c5d6dfee2441aaa7#b3bd8dd5e5b208b2012392e9c5d6dfee2441aaa7" +dependencies = [ + "anyhow", + "chrono", + "cultcache-rs-derive", + "fs2", + "redb", + "rmp-serde", + "serde", + "serde_bytes", + "serde_json", + "uuid", + "windows-sys", +] + +[[package]] +name = "cultcache-rs-derive" +version = "0.1.0" +source = "git+https://github.com/GameCult/CultLib.git?rev=b3bd8dd5e5b208b2012392e9c5d6dfee2441aaa7#b3bd8dd5e5b208b2012392e9c5d6dfee2441aaa7" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "find-msvc-tools" +version = "0.1.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aedcfb3409746eddb02b9e19ebda1c3394f759a152e48ee875a0844d1b955484" + +[[package]] +name = "fs2" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9564fc758e15025b46aa6643b1b77d047d1a56a1aea6e01002ac0c7026876213" +dependencies = [ + "libc", + "winapi", +] + +[[package]] +name = "futures-core" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "92d699e522242e69e3003b94ecc1f960f3a5e015aa7c5d7486e65ad01dd94f5e" + +[[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-task", + "pin-project-lite", + "slab", +] + +[[package]] +name = "getrandom" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099" +dependencies = [ + "cfg-if", + "libc", + "r-efi", +] + +[[package]] +name = "iana-time-zone" +version = "0.1.65" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470" +dependencies = [ + "android_system_properties", + "core-foundation-sys", + "iana-time-zone-haiku", + "js-sys", + "log", + "wasm-bindgen", + "windows-core", +] + +[[package]] +name = "iana-time-zone-haiku" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f" +dependencies = [ + "cc", +] + +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + +[[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 = "libc" +version = "0.2.190" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce5d3ddc6d3fa000eb1536d85e147bfe31aacaba692ed6a876f95cb7c855be78" + +[[package]] +name = "log" +version = "0.4.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6" + +[[package]] +name = "memchr" +version = "2.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", +] + +[[package]] +name = "once_cell" +version = "1.21.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50" + +[[package]] +name = "pin-project-lite" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd" + +[[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 = "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 = "6.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf" + +[[package]] +name = "redb" +version = "4.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fb338a6c67830a61bed824b78c2bb034ab1ff401a20616bd7957524f4fdc2f22" +dependencies = [ + "libc", +] + +[[package]] +name = "rmp" +version = "0.8.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ba8be72d372b2c9b35542551678538b562e7cf86c3315773cae48dfbfe7790c" +dependencies = [ + "num-traits", +] + +[[package]] +name = "rmp-serde" +version = "1.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72f81bee8c8ef9b577d1681a70ebbc962c232461e397b22c208c43c04b67a155" +dependencies = [ + "rmp", + "serde", +] + +[[package]] +name = "rustversion" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f" + +[[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_bytes" +version = "0.11.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a5d440709e79d88e51ac01c4b72fc6cb7314017bb7da9eeff678aa94c10e3ea8" +dependencies = [ + "serde", + "serde_core", +] + +[[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.8", +] + +[[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 = "shlex" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba" + +[[package]] +name = "slab" +version = "0.4.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5" + +[[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.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "01016da373cd8f7ef12624f796309f5c31ba8d646dd08856c02cd741d823c622" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "thing-contract" +version = "0.1.0" +dependencies = [ + "anyhow", + "cultcache-rs", + "rmp-serde", + "serde", + "serde_bytes", +] + +[[package]] +name = "unicode-ident" +version = "1.0.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954" + +[[package]] +name = "uuid" +version = "1.28.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7cc1186384beb7dd8eedea376413fd654937285ea6c9cfbb928dc3043ea4b606" +dependencies = [ + "getrandom", + "js-sys", + "wasm-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-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.8", + "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 = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[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-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-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.59.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" +dependencies = [ + "windows-targets", +] + +[[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_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 = "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..d4018b6 --- /dev/null +++ b/Cargo.toml @@ -0,0 +1,9 @@ +[workspace] +members = ["crates/*"] +resolver = "2" + +[workspace.dependencies] +anyhow = "1" +cultcache-rs = { git = "https://github.com/GameCult/CultLib.git", rev = "b3bd8dd5e5b208b2012392e9c5d6dfee2441aaa7", package = "cultcache-rs" } +serde = { version = "1", features = ["derive"] } +rmp-serde = "1.3" diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..b3fa4fd --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2026 GameCult + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/README.md b/README.md index 476ec0a..8956984 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,41 @@ -# Eve +# Thing + +This repository is Thing (the Eve display, control and sensor edge for GameCult +apps). Its present tree is Thing 1, kept running for live consumers until each +ports; Thing 2.0 is built here (`docs/thing2-target.md`). The Thing 1 renderer +repos are archived under their Eve names: EveUnity, EveFlutter, EveElectron, +EveTui, EvePlugins and EveConformance. + +## Start Here + +Value: services publish a surface once, as a typed retained document +(`gamecult.eve.surface.v1`), and every runtime lowers it locally. Providers keep +authority over state and commands; Eve owns projection, input capture and +timestamped sensor publication. + +Problem: without a shared surface contract, each service hand-builds its own +dashboard and each renderer re-implements layout, binding and commands. + +Live (Thing 1): + +- `packages/org.gamecult.eve.surface`: renderer-neutral C# surface contract and + composition builders; tests in `tests/GameCult.Eve.Surface.Serialization.Tests`. +- `packages/eve-contracts`: TypeScript types and validators generated from + `schemas/` (`npm run generate`, `npm test`). +- `packages/eve-browser-lowering`: browser DOM/CSS lowering of surface documents + (`npm test`). +- `web/`: browser reference oracle (`web/index.html`, `web/eve-dsl.js`; tests + with `node --test web/eve-dsl.test.mjs`). +- `docs/surface-contract-v1.md`: the contract. `docs/repo-strategy.md`: repo + ownership. `docs/parity-testing-harness.md` with + `scripts/run-parity-harness.ps1`: parity runs. +- `android/` and `Sources/` (iOS Theos app, `make package`): native proof + clients; build steps under Build Shape below. + +Planned (Thing 2.0, in progress): `crates/thing-contract` is the first Rust +piece. The layout solver, text, accessibility tree, closed render-command list +and thin backends described in `docs/thing2-target.md` and `docs/thing2-map.md` +are not built yet; `docs/thing-campaign.md` holds the rename plan. CultMesh-based surface web, portable control layer, and timestamped sensor edge. @@ -177,7 +214,6 @@ See `docs/eve-dsl-reactive-bindings.md` for the first Eve DSL and reactive CultMesh binding contract. See `docs/eve-multiverse.md` for the Eve MultiVerse philosophy and missing API surface. -See `docs/eve-face.md` for Eve's persistent mission memory. ## Browser Reference @@ -210,11 +246,8 @@ render: ## VoidBot CEF Stream -Start the Starfire relay from `E:\Projects\VoidBot`: - -```powershell -npm run swarm:eve-cef-relay -- --width 1620 --height 2160 --scale 2 --port 8792 -``` +The CEF relay that produced these frames is not in VoidBot's default branch, so +no relay command is documented here until one exists. EveCanvas displays binary JPEG frames and returns touch events only when a stream lowering is configured through `EVE_STREAM_URLS`. The native app no @@ -222,12 +255,11 @@ longer guesses a Starfire relay address. ## Mimir Sensor Uplink -Start Mimir with `config/mimir-runtime.raven-eve.example.json` or run the -receiver processes directly: +Run the receiver processes from a Mimir checkout (a sibling `..\Mimir` here): ```powershell -dotnet run --project E:\Projects\Mimir\src\Mimir.EveSensorReceiver\Mimir.EveSensorReceiver.csproj -- --port 8793 --path /eve/camera --source-id eve-camera --type video-frame -dotnet run --project E:\Projects\Mimir\src\Mimir.EveSensorReceiver\Mimir.EveSensorReceiver.csproj -- --port 8794 --path /eve/mic --source-id eve-mic --type audio-block +dotnet run --project ..\Mimir\src\Mimir.EveSensorReceiver\Mimir.EveSensorReceiver.csproj -- --port 8793 --path /eve/camera --source-id eve-camera --type video-frame +dotnet run --project ..\Mimir\src\Mimir.EveSensorReceiver\Mimir.EveSensorReceiver.csproj -- --port 8794 --path /eve/mic --source-id eve-mic --type audio-block ``` EveCanvas sends binary `mimir.eve_media_observation.v1` camera and microphone @@ -241,7 +273,7 @@ guess receiver URLs. Start the dashboard authority on Starfire: ```powershell -dotnet run --project E:\Projects\Mimir\src\Mimir.EveDashboard\Mimir.EveDashboard.csproj -- --port 8795 +dotnet run --project ..\Mimir\src\Mimir.EveDashboard\Mimir.EveDashboard.csproj -- --port 8795 ``` EveCanvas connects to the Mimir dashboard WebSocket lowering for native retained @@ -347,8 +379,8 @@ without losing the basic app deployment path. ## Next Cut -- Create the browser reference Eve runtime and use it as the visual/behavior - test oracle for native clients. +- Connect the existing browser reference to a clean-consumer, networked + CultMesh sample and use it as the visual/behavior oracle for native clients. - Split the shared CultNet/CultMesh surface contract from the iOS app code and keep `gamecult.eve.surface.v1` as the renderer-facing contract. - Replace JSON/base64 sensor packets with binary framing once camera and mic diff --git a/crates/thing-contract/Cargo.toml b/crates/thing-contract/Cargo.toml new file mode 100644 index 0000000..f3ffd0f --- /dev/null +++ b/crates/thing-contract/Cargo.toml @@ -0,0 +1,15 @@ +[package] +name = "thing-contract" +version = "0.1.0" +edition = "2024" +license = "MIT" +publish = false + +[dependencies] +anyhow = { workspace = true } +cultcache-rs = { workspace = true } +serde = { workspace = true } +serde_bytes = "0.11" + +[dev-dependencies] +rmp-serde = { workspace = true } diff --git a/crates/thing-contract/src/asset.rs b/crates/thing-contract/src/asset.rs new file mode 100644 index 0000000..9e97d7e --- /dev/null +++ b/crates/thing-contract/src/asset.rs @@ -0,0 +1,39 @@ +//! An asset catalog: the images a provider's surfaces reference by catalog id and asset id. + +use cultcache_rs::{CultSlots, DatabaseEntry}; + +use crate::domain::{Count, Segment, Version}; +use crate::keys::{ProviderId, asset_catalog_key}; + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct AssetEntry { + #[cultcache(key = 0)] + pub id: String, + #[cultcache(key = 1)] + pub media_type: String, + #[cultcache(key = 2)] + pub uri: String, + #[cultcache(key = 3)] + pub width: Count, + #[cultcache(key = 4)] + pub height: Count, +} + +#[derive(Clone, Debug, PartialEq, DatabaseEntry)] +#[cultcache(type = "gamecult.thing.asset_catalog", schema = "gamecult.thing.asset_catalog.v1")] +pub struct AssetCatalog { + #[cultcache(key = 0)] + pub provider_id: ProviderId, + #[cultcache(key = 1)] + pub catalog_id: Segment, + #[cultcache(key = 2)] + pub version: Version, + #[cultcache(key = 3)] + pub assets: Vec, +} + +impl AssetCatalog { + pub fn record_key(&self) -> String { + asset_catalog_key(&self.provider_id, &self.catalog_id) + } +} diff --git a/crates/thing-contract/src/command.rs b/crates/thing-contract/src/command.rs new file mode 100644 index 0000000..6db6a88 --- /dev/null +++ b/crates/thing-contract/src/command.rs @@ -0,0 +1,123 @@ +//! Commands: what a surface declares, and the one envelope a consumer sends. The caller's +//! identity has no field here: the transport sets it. + +use cultcache_rs::{CultSlots, CultUnion, DatabaseEntry}; + +use crate::domain::Version; +use crate::keys::{CommandId, NodeId, SchemaId, invocation_key}; +use crate::source::ParamName; + +/// A command a surface declares. A node may reference only a declared command. +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct CommandDecl { + #[cultcache(key = 0)] + pub id: CommandId, + #[cultcache(key = 1)] + pub payload_schema: SchemaId, + /// The input nodes whose current values travel with an invocation. + #[cultcache(key = 2)] + pub captures: Vec, + #[cultcache(key = 3)] + pub confirm: Option, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct CommandIdRef { + #[cultcache(key = 0)] + pub id: CommandId, +} + +#[derive(Clone, Debug, PartialEq, CultUnion)] +pub enum CommandRef { + #[cultcache(key = 0)] + Id(CommandIdRef), + #[cultcache(key = 1)] + Param(ParamName), +} + +/// A typed record of the declared `payload_schema`, as its MessagePack bytes. +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct RecordPayload { + #[cultcache(key = 0)] + pub schema: SchemaId, + #[cultcache(key = 1, bytes)] + pub bytes: Vec, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct TextValue { + #[cultcache(key = 0)] + pub value: String, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct NumberValue { + #[cultcache(key = 0)] + pub value: f64, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct BoolValue { + #[cultcache(key = 0)] + pub value: bool, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct ChoiceValue { + #[cultcache(key = 0)] + pub value: String, +} + +#[derive(Clone, Debug, PartialEq, CultUnion)] +pub enum InputValue { + #[cultcache(key = 0)] + Text(TextValue), + #[cultcache(key = 1)] + Number(NumberValue), + #[cultcache(key = 2)] + Bool(BoolValue), + #[cultcache(key = 3)] + Choice(ChoiceValue), +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct CapturedInput { + #[cultcache(key = 0)] + pub node: NodeId, + #[cultcache(key = 1)] + pub value: InputValue, +} + +/// A consumer's request that a provider run a declared command. Its fields are public, so a +/// result's copy of `invocation_id` is a convenience and not provenance: core binds results +/// to the invocations it issued. +#[derive(Clone, Debug, PartialEq, DatabaseEntry)] +#[cultcache(type = "gamecult.thing.command_invocation", schema = "gamecult.thing.command_invocation.v1")] +pub struct CommandInvocation { + /// A UUID string, unique per invocation. + #[cultcache(key = 0)] + pub invocation_id: String, + #[cultcache(key = 1)] + pub surface_key: String, + #[cultcache(key = 2)] + pub surface_version: Version, + #[cultcache(key = 3)] + pub command: CommandId, + #[cultcache(key = 4)] + pub payload: RecordPayload, + #[cultcache(key = 5)] + pub captured: Vec, + #[cultcache(key = 6)] + pub client: String, + /// RFC 3339, UTC. + #[cultcache(key = 7)] + pub issued_at: String, + #[cultcache(key = 8)] + pub delegation: Option, +} + +impl CommandInvocation { + pub fn record_key(&self) -> String { + invocation_key(&self.invocation_id) + } +} diff --git a/crates/thing-contract/src/domain.rs b/crates/thing-contract/src/domain.rs new file mode 100644 index 0000000..59e26b0 --- /dev/null +++ b/crates/thing-contract/src/domain.rs @@ -0,0 +1,216 @@ +//! The value domains of the contract's numbers and local names. Each domain is one field +//! type, and `new` is its only door: constructors, struct literals and every serde +//! `Deserializer` reach a value through it, so a value out of domain cannot exist. +//! +//! Each type writes and reads exactly the leaf of its inner type (`Int32`, `Int64`, +//! `String`), so the bytes are the plain leaf's. The reference's unsigned leaves are absent +//! from the TypeScript and Python packages, which is why the bound is a checked type here +//! and a refusal golden there. + +use std::fmt; + +use serde::{Deserialize, Deserializer, Serialize, Serializer, de}; + +/// A value was outside its domain. Names the domain and its bound, never the value. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct DomainError { + domain: &'static str, + bound: &'static str, +} + +impl DomainError { + const fn new(domain: &'static str, bound: &'static str) -> Self { + Self { domain, bound } + } + + /// The type that refused. + pub fn domain(&self) -> &'static str { + self.domain + } + + /// The bound that was not met. + pub fn bound(&self) -> &'static str { + self.bound + } +} + +impl fmt::Display for DomainError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{} must be {}", self.domain, self.bound) + } +} + +impl std::error::Error for DomainError {} + +/// A result's position in its invocation's answers, counting from 1. `new` is the only door: +/// +/// ``` +/// use thing_contract::Seq; +/// assert!(Seq::new(1).is_ok()); +/// ``` +/// +/// ```compile_fail,E0423 +/// use thing_contract::Seq; +/// let _ = Seq(0); +/// ``` +/// +/// ```compile_fail,E0616 +/// use thing_contract::Seq; +/// let mut seq = Seq::FIRST; +/// seq.0 = 0; +/// ``` +/// +/// ```compile_fail,E0599 +/// use thing_contract::Seq; +/// let _ = Seq::default(); +/// ``` +/// +/// ```compile_fail,E0277 +/// use thing_contract::Seq; +/// let _ = Seq::from(0); +/// ``` +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)] +pub struct Seq(i32); + +impl Seq { + pub const FIRST: Seq = Seq(1); + + pub fn new(value: i32) -> Result { + if value >= 1 { Ok(Self(value)) } else { Err(DomainError::new("Seq", "at least 1")) } + } + + pub fn get(self) -> i32 { + self.0 + } + + /// The following position; stays at `i32::MAX` rather than leaving the domain. + pub fn next(self) -> Seq { + Seq(self.0.saturating_add(1)) + } +} + +/// A document or source version, never negative. `new` is the only door: +/// +/// ``` +/// use thing_contract::Version; +/// assert!(Version::new(0).is_ok()); +/// ``` +/// +/// ```compile_fail,E0423 +/// use thing_contract::Version; +/// let _ = Version(-1); +/// ``` +/// +/// ```compile_fail,E0599 +/// use thing_contract::Version; +/// let _ = Version::default(); +/// ``` +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)] +pub struct Version(i64); + +impl Version { + pub fn new(value: i64) -> Result { + if value >= 0 { Ok(Self(value)) } else { Err(DomainError::new("Version", "at least 0")) } + } + + pub fn get(self) -> i64 { + self.0 + } +} + +/// A count, an extent or an index, never negative. `new` is the only door: +/// +/// ``` +/// use thing_contract::Count; +/// assert!(Count::new(0).is_ok()); +/// ``` +/// +/// ```compile_fail,E0423 +/// use thing_contract::Count; +/// let _ = Count(-1); +/// ``` +/// +/// ```compile_fail,E0277 +/// use thing_contract::Count; +/// let _: Count = (-1).into(); +/// ``` +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)] +pub struct Count(i32); + +impl Count { + pub fn new(value: i32) -> Result { + if value >= 0 { Ok(Self(value)) } else { Err(DomainError::new("Count", "at least 0")) } + } + + pub fn get(self) -> i32 { + self.0 + } +} + +/// A name the contract joins into a record key: non-empty, no `.`. `new` is the only door: +/// +/// ``` +/// use thing_contract::Segment; +/// assert!(Segment::new("main").is_ok()); +/// ``` +/// +/// ```compile_fail,E0423 +/// use thing_contract::Segment; +/// let _ = Segment(String::from("a.b")); +/// ``` +/// +/// ```compile_fail,E0277 +/// use thing_contract::Segment; +/// let _: Segment = "a.b".into(); +/// ``` +#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)] +pub struct Segment(String); + +impl Segment { + pub fn new(value: impl Into) -> Result { + let value = value.into(); + if value.is_empty() { + Err(DomainError::new("Segment", "non-empty")) + } else if value.contains('.') { + Err(DomainError::new("Segment", "free of '.'")) + } else { + Ok(Self(value)) + } + } + + pub fn as_str(&self) -> &str { + &self.0 + } +} + +macro_rules! leaf_serde { + ($name:ident, $inner:ty, $serialize:ident) => { + impl Serialize for $name { + fn serialize(&self, serializer: S) -> Result { + serializer.$serialize(self.0) + } + } + + impl<'de> Deserialize<'de> for $name { + fn deserialize>(deserializer: D) -> Result { + Self::new(<$inner>::deserialize(deserializer)?).map_err(de::Error::custom) + } + } + }; +} + +leaf_serde!(Seq, i32, serialize_i32); +leaf_serde!(Version, i64, serialize_i64); +leaf_serde!(Count, i32, serialize_i32); + +impl Serialize for Segment { + fn serialize(&self, serializer: S) -> Result { + serializer.serialize_str(&self.0) + } +} + +impl<'de> Deserialize<'de> for Segment { + fn deserialize>(deserializer: D) -> Result { + Self::new(String::deserialize(deserializer)?).map_err(de::Error::custom) + } +} diff --git a/crates/thing-contract/src/keys.rs b/crates/thing-contract/src/keys.rs new file mode 100644 index 0000000..f6de211 --- /dev/null +++ b/crates/thing-contract/src/keys.rs @@ -0,0 +1,70 @@ +//! Identifier newtypes and the record key of each kind. No caller spells a key as a free string. + +use serde::{Deserialize, Serialize}; + +use crate::domain::{Segment, Seq, Version}; + +macro_rules! id_type { + ($(#[$doc:meta])* $name:ident) => { + $(#[$doc])* + #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)] + #[serde(transparent)] + pub struct $name(String); + + impl $name { + pub fn new(value: impl Into) -> Self { + Self(value.into()) + } + + pub fn as_str(&self) -> &str { + &self.0 + } + } + }; +} + +id_type!( + /// A provider of surfaces and state. + ProviderId +); +id_type!( + /// The schema id of a CultCache entry type, for example `gamecult.thing.surface.v1`. + SchemaId +); +id_type!( + /// The record key of a state record. + RecordKey +); +id_type!( + /// A node id, unique within its document after composition expansion. + NodeId +); +id_type!( + /// A command declared by a surface. + CommandId +); + +// Each key joins free-string provider or publisher ids (dotted, as the Verse names them) +// with typed trailing parts: a `Segment` holds no dot and a `Seq` or `Version` is digits. A +// key therefore splits at its last dot (surface, asset catalog, result) or last two +// (composition), so two different field sets never build one key. + +pub(crate) fn surface_key(provider: &ProviderId, label: &Segment) -> String { + format!("thing:surface:{}.{}", provider.as_str(), label.as_str()) +} + +pub(crate) fn composition_key(publisher: &str, name: &Segment, version: Version) -> String { + format!("thing:composition:{publisher}.{}.v{}", name.as_str(), version.get()) +} + +pub(crate) fn invocation_key(invocation_id: &str) -> String { + format!("thing:invocation:{invocation_id}") +} + +pub(crate) fn result_key(invocation_id: &str, seq: Seq) -> String { + format!("thing:result:{invocation_id}.{}", seq.get()) +} + +pub(crate) fn asset_catalog_key(provider: &ProviderId, catalog_id: &Segment) -> String { + format!("thing:asset_catalog:{}.{}", provider.as_str(), catalog_id.as_str()) +} diff --git a/crates/thing-contract/src/lib.rs b/crates/thing-contract/src/lib.rs new file mode 100644 index 0000000..9f9d544 --- /dev/null +++ b/crates/thing-contract/src/lib.rs @@ -0,0 +1,49 @@ +//! The `gamecult.thing.*` wire types and their bytes. This crate owns the contract: the +//! golden payloads it blesses are what every other language package and core are held to. +//! +//! Every kind is a CultCache `DatabaseEntry`; every closed set is a `CultUnion` written +//! `[armKey, [slots...]]`, the shape the C# reference reads and writes. +//! +//! Decoding is a door as well as the constructors: every kind keeps its public serde +//! `Deserialize` (CultCache's `DatabaseEntry` requires it). The domains therefore live in the +//! field types (`Seq`, `Version`, `Count`, `Segment`), whose `Deserialize` calls the same +//! `new` the constructors call, so no door skips a check. +//! +//! Hazard: decoding these kinds from untrusted bytes on a default-size thread can abort the +//! process inside CultCache's nesting bound before the bound refuses (the stack is not +//! bounded by nesting depth). The owner is `cultlib-gaps:follow_up:decode-stack-safety`; the +//! tests decode on a 16 MiB thread until it lands. + +mod asset; +mod command; +mod domain; +mod keys; +mod node; +mod result; +mod source; +mod style; + +pub use asset::*; +pub use command::*; +pub use domain::{Count, DomainError, Segment, Seq, Version}; +pub use keys::{CommandId, NodeId, ProviderId, RecordKey, SchemaId}; +pub use node::*; +pub use result::*; +pub use source::*; +pub use style::*; + +use cultcache_rs::{CultCache, CultCacheRegistry}; + +/// Registers the five kinds with a cache. +pub struct ThingContract; + +impl CultCacheRegistry for ThingContract { + fn register_entries(&self, cache: &mut CultCache) -> anyhow::Result<()> { + cache.register_entry_type::()?; + cache.register_entry_type::()?; + cache.register_entry_type::()?; + cache.register_entry_type::()?; + cache.register_entry_type::()?; + Ok(()) + } +} diff --git a/crates/thing-contract/src/node.rs b/crates/thing-contract/src/node.rs new file mode 100644 index 0000000..603950b --- /dev/null +++ b/crates/thing-contract/src/node.rs @@ -0,0 +1,455 @@ +//! Thing Script: the closed node union, the surface document that holds a tree of nodes, and the +//! composition document that names a reusable subtree. Arm keys are fixed for v1. + +use cultcache_rs::{CultSlots, CultUnion, DatabaseEntry}; + +use crate::domain::{Count, Segment, Version}; +use crate::command::{CommandDecl, CommandRef}; +use crate::keys::{NodeId, ProviderId, composition_key, surface_key}; +use crate::source::{Bind, BoolSource, CollectionSource, MemberPath, NumberSource, TextSource}; +use crate::style::{BoxStyle, Paint, Role}; + +/// What every node carries. +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct NodeCommon { + #[cultcache(key = 0)] + pub id: NodeId, + #[cultcache(key = 1)] + pub visible: BoolSource, + #[cultcache(key = 2)] + pub a11y_label: Option, +} + +#[derive(Clone, Debug, PartialEq, CultUnion)] +pub enum Node { + #[cultcache(key = 0)] + Box(BoxNode), + #[cultcache(key = 1)] + Text(TextNode), + #[cultcache(key = 2)] + Image(ImageNode), + #[cultcache(key = 3)] + Button(ButtonNode), + #[cultcache(key = 4)] + Toggle(ToggleNode), + #[cultcache(key = 5)] + Slider(SliderNode), + #[cultcache(key = 6)] + TextInput(TextInputNode), + #[cultcache(key = 7)] + Select(SelectNode), + #[cultcache(key = 8)] + Repeat(RepeatNode), + #[cultcache(key = 9)] + Overlay(OverlayNode), + #[cultcache(key = 10)] + Plot(PlotNode), + #[cultcache(key = 11)] + Embed(EmbedNode), + #[cultcache(key = 12)] + Use(UseNode), +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct BoxNode { + #[cultcache(key = 0)] + pub common: NodeCommon, + #[cultcache(key = 1)] + pub style: BoxStyle, + #[cultcache(key = 2)] + pub paint: Paint, + #[cultcache(key = 3)] + pub role: Role, + #[cultcache(key = 4)] + pub children: Vec, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct TextNode { + #[cultcache(key = 0)] + pub common: NodeCommon, + #[cultcache(key = 1)] + pub content: TextSource, + #[cultcache(key = 2)] + pub style_token: String, + #[cultcache(key = 3)] + pub wrap: bool, + #[cultcache(key = 4)] + pub max_lines: Option, + #[cultcache(key = 5)] + pub selectable: bool, +} + +#[derive(Clone, Debug, PartialEq, CultUnion)] +pub enum ImageFit { + #[cultcache(key = 0)] + Contain, + #[cultcache(key = 1)] + Cover, + #[cultcache(key = 2)] + Fill, + #[cultcache(key = 3)] + Unscaled, +} + +/// An asset of a catalog, with the alternative text a reader without the picture needs. +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct ImageNode { + #[cultcache(key = 0)] + pub common: NodeCommon, + #[cultcache(key = 1)] + pub catalog: String, + #[cultcache(key = 2)] + pub asset: String, + #[cultcache(key = 3)] + pub fit: ImageFit, + #[cultcache(key = 4)] + pub alt: TextSource, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct ButtonNode { + #[cultcache(key = 0)] + pub common: NodeCommon, + #[cultcache(key = 1)] + pub content: Vec, + #[cultcache(key = 2)] + pub on_activate: CommandRef, + #[cultcache(key = 3)] + pub enabled: BoolSource, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct ToggleNode { + #[cultcache(key = 0)] + pub common: NodeCommon, + #[cultcache(key = 1)] + pub checked: BoolSource, + #[cultcache(key = 2)] + pub on_change: CommandRef, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct SliderNode { + #[cultcache(key = 0)] + pub common: NodeCommon, + #[cultcache(key = 1)] + pub min: f64, + #[cultcache(key = 2)] + pub max: f64, + #[cultcache(key = 3)] + pub step: f64, + #[cultcache(key = 4)] + pub value: NumberSource, + #[cultcache(key = 5)] + pub commit: CommandRef, +} + +#[derive(Clone, Debug, PartialEq, CultUnion)] +pub enum InputKind { + #[cultcache(key = 0)] + Text, + #[cultcache(key = 1)] + Number, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct TextInputNode { + #[cultcache(key = 0)] + pub common: NodeCommon, + #[cultcache(key = 1)] + pub multiline: bool, + #[cultcache(key = 2)] + pub kind: InputKind, + #[cultcache(key = 3)] + pub placeholder: TextSource, + #[cultcache(key = 4)] + pub initial: TextSource, + #[cultcache(key = 5)] + pub submit: CommandRef, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct SelectOption { + #[cultcache(key = 0)] + pub value: String, + #[cultcache(key = 1)] + pub label: String, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct LiteralOptions { + #[cultcache(key = 0)] + pub options: Vec, +} + +/// Options read from a collection: each item's value and label are members of the item. +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct BoundOptions { + #[cultcache(key = 0)] + pub collection: CollectionSource, + #[cultcache(key = 1)] + pub value_member: MemberPath, + #[cultcache(key = 2)] + pub label_member: MemberPath, +} + +#[derive(Clone, Debug, PartialEq, CultUnion)] +pub enum OptionList { + #[cultcache(key = 0)] + Literal(LiteralOptions), + #[cultcache(key = 1)] + Bound(BoundOptions), +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct SelectNode { + #[cultcache(key = 0)] + pub common: NodeCommon, + #[cultcache(key = 1)] + pub options: OptionList, + #[cultcache(key = 2)] + pub value: Bind, + #[cultcache(key = 3)] + pub on_change: CommandRef, +} + +/// The template is instantiated once per item of the collection, keyed by `key_member` of the item. +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct RepeatNode { + #[cultcache(key = 0)] + pub common: NodeCommon, + #[cultcache(key = 1)] + pub collection: CollectionSource, + #[cultcache(key = 2)] + pub key_member: MemberPath, + #[cultcache(key = 3)] + pub template: std::boxed::Box, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct AnchorNode { + #[cultcache(key = 0)] + pub node: NodeId, +} + +#[derive(Clone, Debug, PartialEq, CultUnion)] +pub enum Anchor { + #[cultcache(key = 0)] + Viewport, + #[cultcache(key = 1)] + Node(AnchorNode), +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct OverlayNode { + #[cultcache(key = 0)] + pub common: NodeCommon, + #[cultcache(key = 1)] + pub anchor: Anchor, + #[cultcache(key = 2)] + pub modal: bool, + #[cultcache(key = 3)] + pub dismiss: CommandRef, + #[cultcache(key = 4)] + pub children: Vec, +} + +#[derive(Clone, Debug, PartialEq, CultUnion)] +pub enum PlotMark { + #[cultcache(key = 0)] + Line, + #[cultcache(key = 1)] + Bar, + #[cultcache(key = 2)] + Area, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct PlotNode { + #[cultcache(key = 0)] + pub common: NodeCommon, + /// A numeric list member of a record. + #[cultcache(key = 1)] + pub series: Bind, + #[cultcache(key = 2)] + pub mark: PlotMark, + #[cultcache(key = 3)] + pub x_min: Option, + #[cultcache(key = 4)] + pub x_max: Option, + #[cultcache(key = 5)] + pub y_min: Option, + #[cultcache(key = 6)] + pub y_max: Option, +} + +/// A leaf the host draws: `slot_kind` is a name the host declares it supports. +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct EmbedNode { + #[cultcache(key = 0)] + pub common: NodeCommon, + #[cultcache(key = 1)] + pub slot_kind: String, + #[cultcache(key = 2)] + pub slot_id: String, + #[cultcache(key = 3)] + pub width: f64, + #[cultcache(key = 4)] + pub height: f64, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct CompositionRef { + #[cultcache(key = 0)] + pub publisher: String, + #[cultcache(key = 1)] + pub name: Segment, + #[cultcache(key = 2)] + pub version: Version, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct UseNode { + #[cultcache(key = 0)] + pub common: NodeCommon, + #[cultcache(key = 1)] + pub composition: CompositionRef, + #[cultcache(key = 2)] + pub args: Vec, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct Arg { + #[cultcache(key = 0)] + pub name: String, + #[cultcache(key = 1)] + pub value: ArgValue, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct TextArg { + #[cultcache(key = 0)] + pub value: String, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct NumberArg { + #[cultcache(key = 0)] + pub value: f64, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct BoolArg { + #[cultcache(key = 0)] + pub value: bool, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct CollectionArg { + #[cultcache(key = 0)] + pub source: CollectionSource, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct CommandArg { + #[cultcache(key = 0)] + pub command: CommandRef, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct SlotArg { + #[cultcache(key = 0)] + pub nodes: Vec, +} + +#[derive(Clone, Debug, PartialEq, CultUnion)] +pub enum ArgValue { + #[cultcache(key = 0)] + Text(TextArg), + #[cultcache(key = 1)] + Number(NumberArg), + #[cultcache(key = 2)] + Bool(BoolArg), + #[cultcache(key = 3)] + Bind(Bind), + #[cultcache(key = 4)] + Collection(CollectionArg), + #[cultcache(key = 5)] + Command(CommandArg), + #[cultcache(key = 6)] + Slot(SlotArg), +} + +#[derive(Clone, Debug, PartialEq, CultUnion)] +pub enum ParamKind { + #[cultcache(key = 0)] + Text, + #[cultcache(key = 1)] + Number, + #[cultcache(key = 2)] + Bool, + #[cultcache(key = 3)] + Bind, + #[cultcache(key = 4)] + Collection, + #[cultcache(key = 5)] + Command, + #[cultcache(key = 6)] + Slot, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct ParamDecl { + #[cultcache(key = 0)] + pub name: String, + #[cultcache(key = 1)] + pub kind: ParamKind, +} + +/// A provider's surface: a tree of nodes and the commands it declares. A change of structure +/// republishes the record with a higher `version`. +#[derive(Clone, Debug, PartialEq, DatabaseEntry)] +#[cultcache(type = "gamecult.thing.surface", schema = "gamecult.thing.surface.v1")] +pub struct SurfaceDocument { + #[cultcache(key = 0)] + pub provider_id: ProviderId, + #[cultcache(key = 1)] + pub label: Segment, + #[cultcache(key = 2)] + pub version: Version, + #[cultcache(key = 3)] + pub title: String, + #[cultcache(key = 4)] + pub root: Node, + #[cultcache(key = 5)] + pub commands: Vec, +} + +impl SurfaceDocument { + pub fn record_key(&self) -> String { + surface_key(&self.provider_id, &self.label) + } +} + +/// A reusable subtree with typed parameters. Compositions never own commands. +#[derive(Clone, Debug, PartialEq, DatabaseEntry)] +#[cultcache(type = "gamecult.thing.composition", schema = "gamecult.thing.composition.v1")] +pub struct CompositionDocument { + #[cultcache(key = 0)] + pub publisher: String, + #[cultcache(key = 1)] + pub name: Segment, + #[cultcache(key = 2)] + pub version: Version, + #[cultcache(key = 3)] + pub params: Vec, + #[cultcache(key = 4)] + pub body: Node, +} + +impl CompositionDocument { + pub fn record_key(&self) -> String { + composition_key(&self.publisher, &self.name, self.version) + } +} diff --git a/crates/thing-contract/src/result.rs b/crates/thing-contract/src/result.rs new file mode 100644 index 0000000..d2a1bb9 --- /dev/null +++ b/crates/thing-contract/src/result.rs @@ -0,0 +1,230 @@ +//! The answer to a command invocation. A `CommandResult` is built by its four constructors, +//! each of which copies the invocation's id, and is read through accessors. Decoding is the +//! other door and holds the same domain: `seq` is a `Seq`, refused below 1 whichever door +//! it enters by. No API takes a state as a string or converts a map. + +use cultcache_rs::{CultSlots, CultUnion, DatabaseEntry}; + +use crate::command::{CommandInvocation, CommandRef}; +use crate::domain::{Seq, Version}; +use crate::keys::{NodeId, result_key}; + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct PendingOutcome { + #[cultcache(key = 0)] + pub message: String, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct CompletedOutcome { + #[cultcache(key = 0)] + pub source_version: Option, + /// Whether the captured drafts of the invocation clear. + #[cultcache(key = 1)] + pub clear_drafts: bool, + #[cultcache(key = 2)] + pub effect: Option, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct DeniedOutcome { + #[cultcache(key = 0)] + pub reason: String, + #[cultcache(key = 1)] + pub node: Option, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct FailedOutcome { + #[cultcache(key = 0)] + pub reason: String, +} + +#[derive(Clone, Debug, PartialEq, CultUnion)] +pub enum Outcome { + #[cultcache(key = 0)] + Pending(PendingOutcome), + #[cultcache(key = 1)] + Completed(CompletedOutcome), + #[cultcache(key = 2)] + Denied(DeniedOutcome), + #[cultcache(key = 3)] + Failed(FailedOutcome), +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct OpenSurfaceEffect { + #[cultcache(key = 0)] + pub key: String, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct OpenExternalEffect { + #[cultcache(key = 0)] + pub url: String, + /// The command run when the external step returns. + #[cultcache(key = 1)] + pub resume: CommandRef, +} + +#[derive(Clone, Debug, PartialEq, CultUnion)] +pub enum Effect { + #[cultcache(key = 0)] + OpenSurface(OpenSurfaceEffect), + #[cultcache(key = 1)] + OpenExternal(OpenExternalEffect), +} + +/// A provider's answer to one invocation. `seq` counts from 1 per invocation. The copied +/// invocation id is a convenience: core binds a result to an invocation it issued. +/// +/// The positive case, a result built by a constructor from the invocation it answers: +/// +/// ``` +/// use thing_contract::{CommandInvocation, CommandResult, Seq}; +/// fn answer(invocation: &CommandInvocation) -> CommandResult { +/// CommandResult::failed(invocation, Seq::FIRST, "refused") +/// } +/// ``` +/// +/// A struct literal does not compile, because the fields are private: +/// +/// ```compile_fail,E0451 +/// use thing_contract::{CommandResult, FailedOutcome, Outcome, Seq}; +/// let _ = CommandResult { +/// invocation_id: String::new(), +/// seq: Seq::FIRST, +/// outcome: Outcome::Failed(FailedOutcome { reason: String::new() }), +/// }; +/// ``` +/// +/// Each field is read through its accessor: +/// +/// ``` +/// use thing_contract::{CommandInvocation, CommandResult, Seq}; +/// fn read(invocation: &CommandInvocation) { +/// let result = CommandResult::failed(invocation, Seq::FIRST, "refused"); +/// let _ = result.invocation_id(); +/// } +/// ``` +/// +/// and assigning it does not compile: +/// +/// ```compile_fail,E0616 +/// use thing_contract::{CommandInvocation, CommandResult, Seq}; +/// fn tamper(invocation: &CommandInvocation) { +/// let mut result = CommandResult::failed(invocation, Seq::FIRST, "refused"); +/// result.invocation_id = String::new(); +/// } +/// ``` +/// +/// ``` +/// use thing_contract::{CommandInvocation, CommandResult, Seq}; +/// fn read(invocation: &CommandInvocation) { +/// let result = CommandResult::failed(invocation, Seq::FIRST, "refused"); +/// let _ = result.seq(); +/// } +/// ``` +/// +/// ```compile_fail,E0616 +/// use thing_contract::{CommandInvocation, CommandResult, Seq}; +/// fn tamper(invocation: &CommandInvocation) { +/// let mut result = CommandResult::failed(invocation, Seq::FIRST, "refused"); +/// result.seq = Seq::FIRST.next(); +/// } +/// ``` +/// +/// ``` +/// use thing_contract::{CommandInvocation, CommandResult, Seq}; +/// fn read(invocation: &CommandInvocation) { +/// let result = CommandResult::failed(invocation, Seq::FIRST, "refused"); +/// let _ = result.outcome(); +/// } +/// ``` +/// +/// ```compile_fail,E0616 +/// use thing_contract::{CommandInvocation, CommandResult, FailedOutcome, Outcome, Seq}; +/// fn tamper(invocation: &CommandInvocation) { +/// let mut result = CommandResult::failed(invocation, Seq::FIRST, "refused"); +/// result.outcome = Outcome::Failed(FailedOutcome { reason: String::new() }); +/// } +/// ``` +/// +/// Nothing converts a map into a result: +/// +/// ```compile_fail,E0277 +/// use std::collections::BTreeMap; +/// use thing_contract::CommandResult; +/// let flat: BTreeMap = BTreeMap::new(); +/// let _ = CommandResult::from(flat); +/// ``` +/// +/// Nor a string state: +/// +/// ```compile_fail,E0277 +/// use thing_contract::CommandResult; +/// let _ = CommandResult::from("completed"); +/// ``` +#[derive(Clone, Debug, PartialEq, DatabaseEntry)] +#[cultcache(type = "gamecult.thing.command_result", schema = "gamecult.thing.command_result.v1")] +pub struct CommandResult { + #[cultcache(key = 0)] + invocation_id: String, + #[cultcache(key = 1)] + seq: Seq, + #[cultcache(key = 2)] + outcome: Outcome, +} + +impl CommandResult { + fn answering(invocation: &CommandInvocation, seq: Seq, outcome: Outcome) -> Self { + Self { invocation_id: invocation.invocation_id.clone(), seq, outcome } + } + + pub fn pending(invocation: &CommandInvocation, seq: Seq, message: impl Into) -> Self { + Self::answering(invocation, seq, Outcome::Pending(PendingOutcome { message: message.into() })) + } + + pub fn completed( + invocation: &CommandInvocation, + seq: Seq, + source_version: Option, + clear_drafts: bool, + effect: Option, + ) -> Self { + Self::answering( + invocation, + seq, + Outcome::Completed(CompletedOutcome { source_version, clear_drafts, effect }), + ) + } + + pub fn denied( + invocation: &CommandInvocation, + seq: Seq, + reason: impl Into, + node: Option, + ) -> Self { + Self::answering(invocation, seq, Outcome::Denied(DeniedOutcome { reason: reason.into(), node })) + } + + pub fn failed(invocation: &CommandInvocation, seq: Seq, reason: impl Into) -> Self { + Self::answering(invocation, seq, Outcome::Failed(FailedOutcome { reason: reason.into() })) + } + + pub fn invocation_id(&self) -> &str { + &self.invocation_id + } + + pub fn seq(&self) -> Seq { + self.seq + } + + pub fn outcome(&self) -> &Outcome { + &self.outcome + } + + pub fn record_key(&self) -> String { + result_key(&self.invocation_id, self.seq) + } +} diff --git a/crates/thing-contract/src/source.rs b/crates/thing-contract/src/source.rs new file mode 100644 index 0000000..c304068 --- /dev/null +++ b/crates/thing-contract/src/source.rs @@ -0,0 +1,170 @@ +//! Where a value comes from: a literal, a binding to a state record, or a composition parameter. +//! A member path is a list of names and indices, never an expression. + +use cultcache_rs::{CultSlots, CultUnion}; + +use crate::domain::Count; +use crate::keys::{ProviderId, RecordKey, SchemaId}; + +/// A composition parameter, named. +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct ParamName { + #[cultcache(key = 0)] + pub name: String, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct TextLiteral { + #[cultcache(key = 0)] + pub value: String, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct NumberLiteral { + #[cultcache(key = 0)] + pub value: f64, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct BoolLiteral { + #[cultcache(key = 0)] + pub value: bool, +} + +#[derive(Clone, Debug, PartialEq, CultUnion)] +pub enum TextSource { + #[cultcache(key = 0)] + Literal(TextLiteral), + #[cultcache(key = 1)] + Bound(Bind), + #[cultcache(key = 2)] + Param(ParamName), +} + +#[derive(Clone, Debug, PartialEq, CultUnion)] +pub enum NumberSource { + #[cultcache(key = 0)] + Literal(NumberLiteral), + #[cultcache(key = 1)] + Bound(Bind), + #[cultcache(key = 2)] + Param(ParamName), +} + +#[derive(Clone, Debug, PartialEq, CultUnion)] +pub enum BoolSource { + #[cultcache(key = 0)] + Literal(BoolLiteral), + #[cultcache(key = 1)] + Bound(Bind), + #[cultcache(key = 2)] + Param(ParamName), +} + +/// One member of a record, read through a path, optionally formatted. +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct Bind { + #[cultcache(key = 0)] + pub source: StateSource, + #[cultcache(key = 1)] + pub member: MemberPath, + #[cultcache(key = 2)] + pub format: Option, +} + +#[derive(Clone, Debug, PartialEq, CultUnion)] +pub enum StateSource { + #[cultcache(key = 0)] + Record(StateRef), + /// The current item inside a `Repeat` template. + #[cultcache(key = 1)] + Item, +} + +/// A state record. An absent provider is the publisher of the document. +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct StateRef { + #[cultcache(key = 0)] + pub provider: Option, + #[cultcache(key = 1)] + pub schema: SchemaId, + #[cultcache(key = 2)] + pub key: RecordKey, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct MemberPath { + #[cultcache(key = 0)] + pub steps: Vec, +} + +#[derive(Clone, Debug, PartialEq, CultUnion)] +pub enum MemberStep { + #[cultcache(key = 0)] + Name(MemberName), + #[cultcache(key = 1)] + Index(MemberIndex), +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct MemberName { + #[cultcache(key = 0)] + pub name: String, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct MemberIndex { + #[cultcache(key = 0)] + pub index: Count, +} + +#[derive(Clone, Debug, PartialEq, CultUnion)] +pub enum Format { + #[cultcache(key = 0)] + Number(NumberFormat), + #[cultcache(key = 1)] + Duration, + #[cultcache(key = 2)] + Timestamp, + #[cultcache(key = 3)] + Affix(AffixFormat), +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct NumberFormat { + #[cultcache(key = 0)] + pub precision: Count, + #[cultcache(key = 1)] + pub percent: bool, + #[cultcache(key = 2)] + pub unit: Option, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct AffixFormat { + #[cultcache(key = 0)] + pub prefix: String, + #[cultcache(key = 1)] + pub suffix: String, +} + +/// The records of one type, or a list member of one record. +#[derive(Clone, Debug, PartialEq, CultUnion)] +pub enum CollectionSource { + #[cultcache(key = 0)] + Records(RecordsSource), + #[cultcache(key = 1)] + Member(Bind), + #[cultcache(key = 2)] + Param(ParamName), +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct RecordsSource { + #[cultcache(key = 0)] + pub provider: Option, + #[cultcache(key = 1)] + pub schema: SchemaId, + #[cultcache(key = 2)] + pub key_prefix: String, +} diff --git a/crates/thing-contract/src/style.rs b/crates/thing-contract/src/style.rs new file mode 100644 index 0000000..1869753 --- /dev/null +++ b/crates/thing-contract/src/style.rs @@ -0,0 +1,241 @@ +//! Box layout and paint as plain data. The crate holds no layout engine: core maps `BoxStyle` +//! onto its solver. + +use cultcache_rs::{CultSlots, CultUnion}; + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct Scalar { + #[cultcache(key = 0)] + pub value: f64, +} + +#[derive(Clone, Debug, PartialEq, CultUnion)] +pub enum Dimension { + #[cultcache(key = 0)] + Px(Scalar), + #[cultcache(key = 1)] + Percent(Scalar), + #[cultcache(key = 2)] + Fr(Scalar), + #[cultcache(key = 3)] + Auto, + #[cultcache(key = 4)] + Content, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct Size2 { + #[cultcache(key = 0)] + pub width: Dimension, + #[cultcache(key = 1)] + pub height: Dimension, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct Edges { + #[cultcache(key = 0)] + pub top: Dimension, + #[cultcache(key = 1)] + pub right: Dimension, + #[cultcache(key = 2)] + pub bottom: Dimension, + #[cultcache(key = 3)] + pub left: Dimension, +} + +#[derive(Clone, Debug, PartialEq, CultUnion)] +pub enum Display { + #[cultcache(key = 0)] + Flex, + #[cultcache(key = 1)] + Grid, + #[cultcache(key = 2)] + Block, +} + +#[derive(Clone, Debug, PartialEq, CultUnion)] +pub enum Direction { + #[cultcache(key = 0)] + Row, + #[cultcache(key = 1)] + Column, + #[cultcache(key = 2)] + RowReverse, + #[cultcache(key = 3)] + ColumnReverse, +} + +#[derive(Clone, Debug, PartialEq, CultUnion)] +pub enum Wrap { + #[cultcache(key = 0)] + NoWrap, + #[cultcache(key = 1)] + Wrap, + #[cultcache(key = 2)] + WrapReverse, +} + +#[derive(Clone, Debug, PartialEq, CultUnion)] +pub enum Position { + #[cultcache(key = 0)] + Relative, + #[cultcache(key = 1)] + Absolute, +} + +#[derive(Clone, Debug, PartialEq, CultUnion)] +pub enum Overflow { + #[cultcache(key = 0)] + Visible, + #[cultcache(key = 1)] + Clip, + #[cultcache(key = 2)] + Scroll, +} + +#[derive(Clone, Debug, PartialEq, CultUnion)] +pub enum ItemAlign { + #[cultcache(key = 0)] + Auto, + #[cultcache(key = 1)] + Start, + #[cultcache(key = 2)] + End, + #[cultcache(key = 3)] + Center, + #[cultcache(key = 4)] + Stretch, + #[cultcache(key = 5)] + Baseline, +} + +#[derive(Clone, Debug, PartialEq, CultUnion)] +pub enum ContentAlign { + #[cultcache(key = 0)] + Auto, + #[cultcache(key = 1)] + Start, + #[cultcache(key = 2)] + End, + #[cultcache(key = 3)] + Center, + #[cultcache(key = 4)] + Stretch, + #[cultcache(key = 5)] + SpaceBetween, + #[cultcache(key = 6)] + SpaceAround, + #[cultcache(key = 7)] + SpaceEvenly, +} + +/// The layout of a box. `gap` is the column gap in `width` and the row gap in `height`. +/// `grid_columns` and `grid_rows` are the grid tracks and are read only when `display` is Grid. +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct BoxStyle { + #[cultcache(key = 0)] + pub display: Display, + #[cultcache(key = 1)] + pub direction: Direction, + #[cultcache(key = 2)] + pub wrap: Wrap, + #[cultcache(key = 3)] + pub gap: Size2, + #[cultcache(key = 4)] + pub padding: Edges, + #[cultcache(key = 5)] + pub margin: Edges, + #[cultcache(key = 6)] + pub size: Size2, + #[cultcache(key = 7)] + pub min_size: Size2, + #[cultcache(key = 8)] + pub max_size: Size2, + #[cultcache(key = 9)] + pub position: Position, + #[cultcache(key = 10)] + pub inset: Edges, + #[cultcache(key = 11)] + pub overflow: Overflow, + #[cultcache(key = 12)] + pub align_items: ItemAlign, + #[cultcache(key = 13)] + pub align_self: ItemAlign, + #[cultcache(key = 14)] + pub align_content: ContentAlign, + #[cultcache(key = 15)] + pub justify_content: ContentAlign, + #[cultcache(key = 16)] + pub grow: f64, + #[cultcache(key = 17)] + pub shrink: f64, + #[cultcache(key = 18)] + pub basis: Dimension, + #[cultcache(key = 19)] + pub grid_columns: Vec, + #[cultcache(key = 20)] + pub grid_rows: Vec, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct ThemeToken { + #[cultcache(key = 0)] + pub name: String, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct Rgba { + #[cultcache(key = 0)] + pub r: u8, + #[cultcache(key = 1)] + pub g: u8, + #[cultcache(key = 2)] + pub b: u8, + #[cultcache(key = 3)] + pub a: u8, +} + +#[derive(Clone, Debug, PartialEq, CultUnion)] +pub enum ColorRef { + #[cultcache(key = 0)] + Token(ThemeToken), + #[cultcache(key = 1)] + Rgba(Rgba), +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct Border { + #[cultcache(key = 0)] + pub color: ColorRef, + #[cultcache(key = 1)] + pub width: f64, +} + +#[derive(Clone, Debug, PartialEq, CultSlots)] +pub struct Paint { + #[cultcache(key = 0)] + pub background: Option, + #[cultcache(key = 1)] + pub border: Option, + #[cultcache(key = 2)] + pub radius: f64, +} + +/// The accessibility role of a box. The accessibility tree itself is core's. +#[derive(Clone, Debug, PartialEq, CultUnion)] +pub enum Role { + #[cultcache(key = 0)] + Group, + #[cultcache(key = 1)] + Region, + #[cultcache(key = 2)] + List, + #[cultcache(key = 3)] + ListItem, + #[cultcache(key = 4)] + Heading, + #[cultcache(key = 5)] + Dialog, + #[cultcache(key = 6)] + Toolbar, +} diff --git a/crates/thing-contract/tests/common/mod.rs b/crates/thing-contract/tests/common/mod.rs new file mode 100644 index 0000000..ee6f71b --- /dev/null +++ b/crates/thing-contract/tests/common/mod.rs @@ -0,0 +1,146 @@ +//! Constructors for the values the goldens and the other tests share. Every value is built +//! through the crate's public types; no bytes are spelled here. + +#![allow(dead_code)] + +use thing_contract::*; + +pub fn seq(value: i32) -> Seq { + Seq::new(value).unwrap() +} + +pub fn ver(value: i64) -> Version { + Version::new(value).unwrap() +} + +pub fn count(value: i32) -> Count { + Count::new(value).unwrap() +} + +pub fn seg(value: &str) -> Segment { + Segment::new(value).unwrap() +} + +pub fn nid(id: &str) -> NodeId { + NodeId::new(id) +} + +pub fn lit_text(value: &str) -> TextSource { + TextSource::Literal(TextLiteral { value: value.into() }) +} + +pub fn lit_bool(value: bool) -> BoolSource { + BoolSource::Literal(BoolLiteral { value }) +} + +pub fn lit_number(value: f64) -> NumberSource { + NumberSource::Literal(NumberLiteral { value }) +} + +pub fn param(name: &str) -> ParamName { + ParamName { name: name.into() } +} + +pub fn path(names: &[&str]) -> MemberPath { + MemberPath { steps: names.iter().map(|name| MemberStep::Name(MemberName { name: (*name).into() })).collect() } +} + +pub fn record_bind(member: MemberPath, format: Option) -> Bind { + Bind { + source: StateSource::Record(StateRef { + provider: Some(ProviderId::new("provider.a")), + schema: SchemaId::new("gamecult.thing.test.v1"), + key: RecordKey::new("row-1"), + }), + member, + format, + } +} + +pub fn item_bind(member: MemberPath) -> Bind { + Bind { source: StateSource::Item, member, format: None } +} + +pub fn command(id: &str) -> CommandRef { + CommandRef::Id(CommandIdRef { id: CommandId::new(id) }) +} + +pub fn common(id: &str) -> NodeCommon { + NodeCommon { id: nid(id), visible: lit_bool(true), a11y_label: None } +} + +pub fn px(value: f64) -> Dimension { + Dimension::Px(Scalar { value }) +} + +pub fn size2(width: Dimension, height: Dimension) -> Size2 { + Size2 { width, height } +} + +pub fn edges(all: Dimension) -> Edges { + Edges { top: all.clone(), right: all.clone(), bottom: all.clone(), left: all } +} + +pub fn style() -> BoxStyle { + BoxStyle { + display: Display::Flex, + direction: Direction::Column, + wrap: Wrap::NoWrap, + gap: size2(px(4.0), px(8.0)), + padding: edges(px(2.0)), + margin: edges(Dimension::Auto), + size: size2(Dimension::Percent(Scalar { value: 100.0 }), Dimension::Content), + min_size: size2(px(0.0), px(0.0)), + max_size: size2(Dimension::Auto, Dimension::Auto), + position: Position::Relative, + inset: edges(Dimension::Auto), + overflow: Overflow::Visible, + align_items: ItemAlign::Stretch, + align_self: ItemAlign::Auto, + align_content: ContentAlign::Start, + justify_content: ContentAlign::SpaceBetween, + grow: 1.0, + shrink: 0.0, + basis: Dimension::Auto, + grid_columns: vec![], + grid_rows: vec![], + } +} + +pub fn plain_paint() -> Paint { + Paint { background: None, border: None, radius: 0.0 } +} + +pub fn boxed(id: &str, children: Vec) -> Node { + Node::Box(BoxNode { common: common(id), style: style(), paint: plain_paint(), role: Role::Group, children }) +} + +pub fn text(id: &str, content: &str) -> Node { + Node::Text(TextNode { + common: common(id), + content: lit_text(content), + style_token: "body".into(), + wrap: true, + max_lines: None, + selectable: false, + }) +} + +pub fn invocation() -> CommandInvocation { + CommandInvocation { + invocation_id: "3f2b8c1e-5d44-4a6b-9a07-1c2d3e4f5a6b".into(), + surface_key: "thing:surface:provider.a.main".into(), + surface_version: ver(7), + command: CommandId::new("go"), + payload: RecordPayload { schema: SchemaId::new("gamecult.thing.test.go.v1"), bytes: vec![0x91, 0x01, 0xff, 0x00] }, + captured: vec![ + CapturedInput { node: nid("name-input"), value: InputValue::Text(TextValue { value: "Ada".into() }) }, + CapturedInput { node: nid("level"), value: InputValue::Number(NumberValue { value: 0.75 }) }, + CapturedInput { node: nid("flag"), value: InputValue::Bool(BoolValue { value: true }) }, + CapturedInput { node: nid("pick"), value: InputValue::Choice(ChoiceValue { value: "a".into() }) }, + ], + client: "renderer.web".into(), + issued_at: "2026-01-01T00:00:00Z".into(), + delegation: Some("delegate-1".into()), + } +} diff --git a/crates/thing-contract/tests/goldens.rs b/crates/thing-contract/tests/goldens.rs new file mode 100644 index 0000000..71a5c23 --- /dev/null +++ b/crates/thing-contract/tests/goldens.rs @@ -0,0 +1,712 @@ +//! The goldens: payload bytes written by this crate and nobody else, then compared byte for +//! byte. The TypeScript and C# packages and core are held to these files; none of them writes +//! one. `THING_BLESS=1` rewrites them; any other run compares. + +mod common; + +use std::collections::BTreeSet; +use std::fmt::Debug; +use std::path::PathBuf; + +use common::*; +use cultcache_rs::{CultCache, CultCacheEnvelope, CultCacheRegistry, DatabaseEntry, SingleFileMessagePackBackingStore}; +use thing_contract::*; + +const PINNED_CLOCK: &str = "2026-01-01T00:00:00Z"; +// A value that must never appear in a refusal. +const CANARY: &str = "CANARY-7f3a91c2"; + +fn goldens_dir() -> PathBuf { + PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/goldens") +} + +fn blessing() -> bool { + std::env::var("THING_BLESS").as_deref() == Ok("1") +} + +/// Bless the file or compare against it. Returns the committed bytes. +fn golden_bytes(file: &str, produced: &[u8]) -> Vec { + let path = goldens_dir().join(file); + if blessing() { + std::fs::write(&path, produced).unwrap_or_else(|error| panic!("{file}: {error}")); + } + let committed = std::fs::read(&path).unwrap_or_else(|error| panic!("{file}: {error}")); + assert_eq!(committed, produced, "{file}: the committed golden differs from what the crate writes"); + committed +} + +fn golden(name: &str, value: &T) -> String { + let produced = rmp_serde::to_vec(value).unwrap(); + let committed = golden_bytes(&format!("{name}.bin"), &produced); + let decoded: T = rmp_serde::from_slice(&committed).unwrap_or_else(|error| panic!("{name}: {error}")); + assert_eq!(&decoded, value, "{name}: the golden does not decode to the constructed value"); + assert_eq!(rmp_serde::to_vec(&decoded).unwrap(), committed, "{name}: re-encoding changed the bytes"); + name.to_string() +} + +fn bind_all_formats() -> Vec { + let number = Format::Number(NumberFormat { precision: count(2), percent: true, unit: Some("ms".into()) }); + let affix = Format::Affix(AffixFormat { prefix: "$".into(), suffix: "/s".into() }); + let indexed = MemberPath { + steps: vec![ + MemberStep::Name(MemberName { name: "items".into() }), + MemberStep::Index(MemberIndex { index: count(3) }), + ], + }; + vec![ + record_bind(indexed, Some(number)), + record_bind(path(&["elapsed"]), Some(Format::Duration)), + record_bind(path(&["at"]), Some(Format::Timestamp)), + record_bind(path(&["price"]), Some(affix)), + record_bind(path(&["plain"]), None), + item_bind(path(&["name"])), + ] +} + +/// A surface using all 13 node arms, nested more than four deep, with every source arm. +fn full_surface() -> SurfaceDocument { + let binds = bind_all_formats(); + let bound_text = TextSource::Bound(binds[3].clone()); + let bound_bool = BoolSource::Bound(binds[4].clone()); + let bound_number = NumberSource::Bound(binds[0].clone()); + + let mut painted = BoxNode { + common: NodeCommon { + id: nid("painted"), + visible: BoolSource::Param(param("show")), + a11y_label: Some(TextSource::Param(param("label"))), + }, + style: style(), + paint: Paint { + background: Some(ColorRef::Token(ThemeToken { name: "surface.raised".into() })), + border: Some(Border { color: ColorRef::Rgba(Rgba { r: 1, g: 2, b: 3, a: 255 }), width: 1.5 }), + radius: 4.0, + }, + role: Role::Region, + children: vec![], + }; + painted.style.display = Display::Grid; + painted.style.grid_columns = vec![Dimension::Fr(Scalar { value: 1.0 }), px(120.0)]; + painted.style.grid_rows = vec![Dimension::Content]; + painted.style.position = Position::Absolute; + painted.style.overflow = Overflow::Scroll; + painted.style.direction = Direction::RowReverse; + painted.style.wrap = Wrap::WrapReverse; + painted.style.align_items = ItemAlign::Baseline; + painted.style.align_self = ItemAlign::Center; + painted.style.align_content = ContentAlign::SpaceAround; + painted.style.justify_content = ContentAlign::SpaceEvenly; + painted.children = vec![text("deep-text", "deep")]; + + let repeat = Node::Repeat(RepeatNode { + common: common("rows"), + collection: CollectionSource::Records(RecordsSource { + provider: None, + schema: SchemaId::new("gamecult.thing.test.v1"), + key_prefix: "row-".into(), + }), + key_member: path(&["id"]), + template: std::boxed::Box::new(Node::Text(TextNode { + common: common("row-name"), + content: TextSource::Bound(item_bind(path(&["name"]))), + style_token: "body".into(), + wrap: false, + max_lines: Some(count(2)), + selectable: true, + })), + }); + + let leaves = vec![ + Node::Text(TextNode { + common: common("t-bound"), + content: bound_text, + style_token: "label".into(), + wrap: true, + max_lines: None, + selectable: false, + }), + Node::Image(ImageNode { + common: common("img"), + catalog: "icons".into(), + asset: "gear".into(), + fit: ImageFit::Cover, + alt: lit_text("a gear"), + }), + Node::Button(ButtonNode { + common: common("go"), + content: vec![text("go-label", "Go")], + on_activate: command("go"), + enabled: bound_bool.clone(), + }), + Node::Toggle(ToggleNode { common: common("flag"), checked: bound_bool, on_change: CommandRef::Param(param("toggle")) }), + Node::Slider(SliderNode { + common: common("level"), + min: 0.0, + max: 1.0, + step: 0.25, + value: bound_number, + commit: command("set-level"), + }), + Node::TextInput(TextInputNode { + common: common("name-input"), + multiline: true, + kind: InputKind::Number, + placeholder: lit_text("name"), + initial: TextSource::Param(param("initial")), + submit: command("rename"), + }), + Node::TextInput(TextInputNode { + common: common("title-input"), + multiline: false, + kind: InputKind::Text, + placeholder: lit_text("title"), + initial: TextSource::Param(param("initial")), + submit: command("retitle"), + }), + Node::Select(SelectNode { + common: common("pick"), + options: OptionList::Literal(LiteralOptions { + options: vec![SelectOption { value: "a".into(), label: "Alpha".into() }], + }), + value: binds[4].clone(), + on_change: command("pick"), + }), + Node::Select(SelectNode { + common: common("pick-bound"), + options: OptionList::Bound(BoundOptions { + collection: CollectionSource::Member(binds[0].clone()), + value_member: path(&["id"]), + label_member: path(&["name"]), + }), + value: binds[5].clone(), + on_change: command("pick"), + }), + repeat, + Node::Overlay(OverlayNode { + common: common("menu"), + anchor: Anchor::Node(AnchorNode { node: nid("go") }), + modal: false, + dismiss: command("close"), + children: vec![text("menu-item", "one")], + }), + Node::Overlay(OverlayNode { + common: common("dialog"), + anchor: Anchor::Viewport, + modal: true, + dismiss: command("close"), + children: vec![], + }), + Node::Plot(PlotNode { + common: common("trend"), + series: binds[1].clone(), + mark: PlotMark::Area, + x_min: Some(0.0), + x_max: None, + y_min: None, + y_max: Some(100.0), + }), + Node::Embed(EmbedNode { + common: common("viewport"), + slot_kind: "world.scene".into(), + slot_id: "main".into(), + width: 640.0, + height: 480.0, + }), + Node::Use(UseNode { + common: common("kv"), + composition: CompositionRef { publisher: "thing.std".into(), name: seg("key-value"), version: ver(1) }, + args: vec![Arg { name: "key".into(), value: ArgValue::Text(TextArg { value: "k".into() }) }], + }), + ]; + + let mut deep = boxed("d4", vec![Node::Box(painted)]); + for id in ["d3", "d2", "d1"] { + deep = boxed(id, vec![deep]); + } + let mut children = vec![deep]; + children.extend(leaves); + for plot_choice in [ + Node::Plot(PlotNode { + common: common("trend-line"), + series: binds[2].clone(), + mark: PlotMark::Line, + x_min: None, + x_max: None, + y_min: None, + y_max: None, + }), + Node::Plot(PlotNode { + common: common("trend-bar"), + series: binds[2].clone(), + mark: PlotMark::Bar, + x_min: None, + x_max: None, + y_min: None, + y_max: None, + }), + ] { + children.push(plot_choice); + } + for (index, fit) in [ImageFit::Contain, ImageFit::Fill, ImageFit::Unscaled].into_iter().enumerate() { + children.push(Node::Image(ImageNode { + common: common(&format!("img-fit-{index}")), + catalog: "icons".into(), + asset: "gear".into(), + fit, + alt: lit_text(""), + })); + } + for (index, role) in [Role::List, Role::ListItem, Role::Heading, Role::Dialog, Role::Toolbar].into_iter().enumerate() { + let mut role_style = style(); + if index == 0 { + role_style.direction = Direction::Row; + role_style.align_content = ContentAlign::Auto; + role_style.justify_content = ContentAlign::Stretch; + } + children.push(Node::Box(BoxNode { + common: common(&format!("role-{index}")), + style: role_style, + paint: plain_paint(), + role, + children: vec![], + })); + } + let mut block = BoxNode { + common: common("block"), + style: style(), + paint: plain_paint(), + role: Role::Group, + children: vec![], + }; + block.style.display = Display::Block; + block.style.direction = Direction::ColumnReverse; + block.style.wrap = Wrap::Wrap; + block.style.overflow = Overflow::Clip; + block.style.align_content = ContentAlign::Center; + block.style.justify_content = ContentAlign::End; + block.style.align_items = ItemAlign::End; + block.style.align_self = ItemAlign::Start; + block.style.basis = Dimension::Content; + children.push(Node::Box(block)); + children.push(Node::Text(TextNode { + common: common("t-param"), + content: TextSource::Param(param("title")), + style_token: "title".into(), + wrap: true, + max_lines: None, + selectable: false, + })); + children.push(Node::Toggle(ToggleNode { + common: NodeCommon { id: nid("literal-number"), visible: BoolSource::Param(param("v")), a11y_label: None }, + checked: lit_bool(false), + on_change: command("toggle"), + })); + children.push(Node::Slider(SliderNode { + common: common("slider-literal"), + min: -1.0, + max: 1.0, + step: 0.5, + value: lit_number(0.5), + commit: command("set-level"), + })); + children.push(Node::Slider(SliderNode { + common: common("slider-param"), + min: 0.0, + max: 10.0, + step: 1.0, + value: NumberSource::Param(param("n")), + commit: command("set-level"), + })); + children.push(Node::Repeat(RepeatNode { + common: common("rows-param"), + collection: CollectionSource::Param(param("rows")), + key_member: path(&["id"]), + template: std::boxed::Box::new(text("row-param", "r")), + })); + + SurfaceDocument { + provider_id: ProviderId::new("provider.a"), + label: seg("main"), + version: ver(7), + title: "All arms".into(), + root: boxed("root", children), + commands: vec![ + CommandDecl { + id: CommandId::new("go"), + payload_schema: SchemaId::new("gamecult.thing.test.go.v1"), + captures: vec![nid("name-input"), nid("level")], + confirm: Some("Go now?".into()), + }, + CommandDecl { + id: CommandId::new("close"), + payload_schema: SchemaId::new("gamecult.thing.test.close.v1"), + captures: vec![], + confirm: None, + }, + ], + } +} + +fn full_composition() -> CompositionDocument { + let args = vec![ + Arg { name: "text".into(), value: ArgValue::Text(TextArg { value: "t".into() }) }, + Arg { name: "number".into(), value: ArgValue::Number(NumberArg { value: 2.5 }) }, + Arg { name: "bool".into(), value: ArgValue::Bool(BoolArg { value: true }) }, + Arg { name: "bind".into(), value: ArgValue::Bind(record_bind(path(&["x"]), None)) }, + Arg { + name: "collection".into(), + value: ArgValue::Collection(CollectionArg { source: CollectionSource::Param(param("rows")) }), + }, + Arg { name: "command".into(), value: ArgValue::Command(CommandArg { command: command("go") }) }, + Arg { + name: "slot".into(), + value: ArgValue::Slot(SlotArg { nodes: vec![text("slot-text", "inside"), boxed("slot-box", vec![])] }), + }, + ]; + let inner_use = Node::Use(UseNode { + common: common("inner"), + composition: CompositionRef { publisher: "thing.std".into(), name: seg("card"), version: ver(2) }, + args, + }); + CompositionDocument { + publisher: "provider.a".into(), + name: seg("panel"), + version: ver(3), + params: [ + ("title", ParamKind::Text), + ("count", ParamKind::Number), + ("on", ParamKind::Bool), + ("source", ParamKind::Bind), + ("rows", ParamKind::Collection), + ("act", ParamKind::Command), + ("body", ParamKind::Slot), + ] + .into_iter() + .map(|(name, kind)| ParamDecl { name: name.into(), kind }) + .collect(), + body: boxed("panel-root", vec![text("panel-title", "t"), inner_use]), + } +} + +fn results(invocation: &CommandInvocation) -> Vec<(&'static str, CommandResult)> { + vec![ + ("result-pending", CommandResult::pending(invocation, seq(1), "working")), + ("result-completed", CommandResult::completed(invocation, seq(2), Some(ver(8)), true, None)), + ( + "result-completed-open-surface", + CommandResult::completed( + invocation, + seq(3), + None, + false, + Some(Effect::OpenSurface(OpenSurfaceEffect { key: "thing:surface:provider.a.next".into() })), + ), + ), + ( + "result-completed-open-external", + CommandResult::completed( + invocation, + seq(4), + Some(ver(9)), + true, + Some(Effect::OpenExternal(OpenExternalEffect { + url: "https://example.test/auth".into(), + resume: command("resume"), + })), + ), + ), + ("result-denied", CommandResult::denied(invocation, seq(5), "not yours", Some(nid("go")))), + ("result-denied-no-node", CommandResult::denied(invocation, seq(6), "not allowed", None)), + ("result-failed", CommandResult::failed(invocation, seq(7), "broke")), + ] +} + +fn asset_catalog() -> AssetCatalog { + AssetCatalog { + provider_id: ProviderId::new("provider.a"), + catalog_id: seg("icons"), + version: ver(2), + assets: vec![ + AssetEntry { id: "gear".into(), media_type: "image/png".into(), uri: "assets/gear.png".into(), width: count(32), height: count(32) }, + AssetEntry { id: "bolt".into(), media_type: "image/svg+xml".into(), uri: "assets/bolt.svg".into(), width: count(0), height: count(0) }, + ], + } +} + +/// A store with one record of each kind, written by cultcache-rs under a pinned clock. +fn write_store(path: &std::path::Path) { + let _ = std::fs::remove_file(path); + let mut cache = CultCache::new(); + ThingContract.register_entries(&mut cache).unwrap(); + cache.add_generic_backing_store(SingleFileMessagePackBackingStore::new(path)).unwrap(); + let surface = full_surface(); + let composition = full_composition(); + let invocation = invocation(); + let result = CommandResult::pending(&invocation, seq(1), "working"); + let catalog = asset_catalog(); + put(&mut cache, &surface.record_key(), &surface); + put(&mut cache, &composition.record_key(), &composition); + put(&mut cache, &invocation.record_key(), &invocation); + put(&mut cache, &result.record_key(), &result); + put(&mut cache, &catalog.record_key(), &catalog); +} + +fn put(cache: &mut CultCache, key: &str, value: &T) { + let (mut envelope, _) = cache.prepare_entry(key, value).unwrap(); + envelope.stored_at = PINNED_CLOCK.into(); + cache.put_envelope::(envelope).unwrap(); +} + +fn envelope(key: &str, payload: Vec) -> CultCacheEnvelope { + CultCacheEnvelope { + key: key.into(), + r#type: T::TYPE.into(), + payload, + stored_at: PINNED_CLOCK.into(), + schema_id: Some(T::TYPE.into()), + } +} + +fn open_store(path: &std::path::Path) -> CultCache { + let mut cache = CultCache::new(); + ThingContract.register_entries(&mut cache).unwrap(); + cache.add_generic_backing_store(SingleFileMessagePackBackingStore::new(path)).unwrap(); + cache.pull_all_backing_stores().unwrap(); + cache +} + +#[test] +fn goldens_match() { + let mut names = BTreeSet::new(); + names.insert(golden("surface-all-arms", &full_surface())); + names.insert(golden("composition-all-params", &full_composition())); + let invocation = invocation(); + names.insert(golden("invocation-all-inputs", &invocation)); + for (name, result) in results(&invocation) { + names.insert(golden(name, &result)); + } + names.insert(golden("asset-catalog", &asset_catalog())); + + // The refusal and tolerance goldens are written by `refusal_payloads` below; a stale file + // that no case names is an orphan. + let refusals = refusal_payloads(); + for (name, bytes) in &refusals { + golden_bytes(&format!("{name}.bin"), bytes); + names.insert((*name).to_string()); + } + let on_disk: BTreeSet = std::fs::read_dir(goldens_dir()) + .unwrap() + .filter_map(|entry| entry.unwrap().file_name().into_string().ok()) + .filter_map(|file| file.strip_suffix(".bin").map(str::to_string)) + .collect(); + assert_eq!(on_disk, names, "every .bin golden is a named case and every case has its file"); + + // The store: one record of each kind, written under a pinned clock, byte for byte. + let scratch = PathBuf::from(env!("CARGO_TARGET_TMPDIR")).join("goldens-surface.cc"); + write_store(&scratch); + let committed = golden_bytes("surface.cc", &std::fs::read(&scratch).unwrap()); + let reopened = goldens_dir().join("surface.cc"); + assert_eq!(std::fs::read(&reopened).unwrap(), committed); + let cache = open_store(&scratch); + let surface = full_surface(); + assert_eq!(cache.get::(&surface.record_key()).unwrap(), Some(surface)); + let composition = full_composition(); + assert_eq!(cache.get::(&composition.record_key()).unwrap(), Some(composition)); + assert_eq!(cache.get::(&invocation.record_key()).unwrap(), Some(invocation.clone())); + let result = CommandResult::pending(&invocation, seq(1), "working"); + assert_eq!(cache.get::(&result.record_key()).unwrap(), Some(result)); + let catalog = asset_catalog(); + assert_eq!(cache.get::(&catalog.record_key()).unwrap(), Some(catalog)); +} + +/// The foreign and malformed payloads. Each is the bytes a consumer might send; none is a +/// value of this crate, so each is spelled from MessagePack tuples and maps. +fn refusal_payloads() -> Vec<(&'static str, Vec)> { + // The map a Thing 1 provider writes for a command result: named members, a receipt + // inside, no positional slots. + #[derive(serde::Serialize)] + #[serde(rename_all = "camelCase")] + struct Receipt { + command_id: &'static str, + command: &'static str, + state: &'static str, + message: &'static str, + source_version: u64, + issued_at_utc: &'static str, + } + #[derive(serde::Serialize)] + struct Flat { + receipt: Receipt, + } + let flat = Flat { + receipt: Receipt { + command_id: "inv-1", + command: "go", + state: "completed", + message: CANARY, + source_version: 4, + issued_at_utc: "2026-01-01T00:00:00Z", + }, + }; + let unit: [u8; 0] = []; + let pending = Outcome::Pending(PendingOutcome { message: CANARY.into() }); + let root = text("root", "x"); + vec![ + ("result-thing1-flat", rmp_serde::to_vec_named(&flat).unwrap()), + // A surface whose root is an arm key the Node union does not declare. + ( + "node-unknown-arm", + rmp_serde::to_vec(&("provider.a", "main", 1i64, CANARY, (13i32, (CANARY,)), unit)).unwrap(), + ), + // A result whose outcome is an arm key the Outcome union does not declare. + ("outcome-unknown-arm", rmp_serde::to_vec(&("inv-1", 1i32, (4i32, (CANARY,)))).unwrap()), + // A result with a fourth slot past the last declared one. + ( + "result-extra-slot", + rmp_serde::to_vec(&("inv-1", 1i32, (0i32, ("working",)), CANARY)).unwrap(), + ), + // Each domain refusal is a tuple of real values with one slot out of domain. + // A result at seq 0. + ("result-seq-zero", rmp_serde::to_vec(&("inv-1", 0i32, &pending)).unwrap()), + // A surface at version -1. + ( + "surface-version-negative", + rmp_serde::to_vec(&("provider.a", "main", -1i64, CANARY, &root, unit)).unwrap(), + ), + // A surface whose label holds a dot, so its key would be ambiguous. + ( + "surface-label-dotted", + rmp_serde::to_vec(&("provider.a", "b.c", 1i64, CANARY, &root, unit)).unwrap(), + ), + // An asset whose width is negative. + ( + "asset-extent-negative", + rmp_serde::to_vec(&("provider.a", "icons", 1i64, [("gear", "image/png", CANARY, -5i32, 32i32)])).unwrap(), + ), + // A colour channel past the u8 leaf. + ("rgba-channel-out-of-range", rmp_serde::to_vec(&(256i32, 0i32, 0i32, 255i32)).unwrap()), + ] +} + +#[test] +fn refusal_cases() { + let payloads: std::collections::BTreeMap<_, _> = refusal_payloads().into_iter().collect(); + let committed = |name: &str| golden_bytes(&format!("{name}.bin"), &payloads[name]); + + // Stored under their key, each is refused naming the kind and the key, never a value. + let cases: [(&str, &str, &str); 7] = [ + ("result-thing1-flat", "gamecult.thing.command_result", "thing:result:inv-1.1"), + ("node-unknown-arm", "gamecult.thing.surface", "thing:surface:provider.a.main"), + ("outcome-unknown-arm", "gamecult.thing.command_result", "thing:result:inv-1.1"), + ("result-seq-zero", "gamecult.thing.command_result", "thing:result:inv-1.0"), + ("surface-version-negative", "gamecult.thing.surface", "thing:surface:provider.a.main"), + ("surface-label-dotted", "gamecult.thing.surface", "thing:surface:provider.a.b.c"), + ("asset-extent-negative", "gamecult.thing.asset_catalog", "thing:asset_catalog:provider.a.icons"), + ]; + for (name, kind, key) in cases { + let mut cache = CultCache::new(); + ThingContract.register_entries(&mut cache).unwrap(); + let bytes = committed(name); + let error = match kind { + "gamecult.thing.surface" => { + cache.put_envelope::(envelope::(key, bytes)).unwrap_err() + } + "gamecult.thing.asset_catalog" => { + cache.put_envelope::(envelope::(key, bytes)).unwrap_err() + } + _ => cache.put_envelope::(envelope::(key, bytes)).unwrap_err(), + }; + let message = format!("{error:#}"); + assert!(message.contains(kind), "{name}: the error names the kind: {message}"); + assert!(message.contains(key), "{name}: the error names the record key: {message}"); + assert!(!message.contains(CANARY), "{name}: the error echoed a value: {message}"); + } + + // Decoded directly, the refusal names the union and the arm key, and never the payload. + for (name, union, key) in [("node-unknown-arm", "Node", "13"), ("outcome-unknown-arm", "Outcome", "4")] { + let bytes = committed(name); + let message = if union == "Node" { + rmp_serde::from_slice::(&bytes).unwrap_err().to_string() + } else { + rmp_serde::from_slice::(&bytes).unwrap_err().to_string() + }; + assert!(message.contains(union) && message.contains(key), "{name}: {message}"); + assert!(!message.contains(CANARY), "{name}: {message}"); + } + + // Decoded directly, a domain refusal names the domain and never the payload. + for (name, domain) in [ + ("result-seq-zero", "Seq"), + ("surface-version-negative", "Version"), + ("surface-label-dotted", "Segment"), + ("asset-extent-negative", "Count"), + ] { + let bytes = committed(name); + let message = match name { + "result-seq-zero" => rmp_serde::from_slice::(&bytes).unwrap_err().to_string(), + "asset-extent-negative" => rmp_serde::from_slice::(&bytes).unwrap_err().to_string(), + _ => rmp_serde::from_slice::(&bytes).unwrap_err().to_string(), + }; + assert!(message.contains(domain), "{name}: {message}"); + assert!(!message.contains(CANARY), "{name}: {message}"); + } + + // The u8 leaf refuses a channel past 255 when decoded as an Rgba. + let rgba = rmp_serde::from_slice::(&committed("rgba-channel-out-of-range")).unwrap_err(); + assert!(!rgba.to_string().contains(CANARY)); + + // An extra trailing slot is read (CultLib's extra-trailing-slots ruling: read, never written + // back). Whether a missing slot is refused is CultLib's rule, so no golden asserts it. + let mut answered = invocation(); + answered.invocation_id = "inv-1".into(); + let extra: CommandResult = rmp_serde::from_slice(&committed("result-extra-slot")).unwrap(); + assert_eq!(extra, CommandResult::pending(&answered, seq(1), "working")); +} + +#[test] +fn deep_tree() { + // Decoding a Node costs tens of KiB of debug stack per nesting level, so the chain runs on a + // thread that has the room; the 2 MiB default does not. The hazard is CultCache's, owned by + // cultlib-gaps:follow_up:decode-stack-safety; the test stays on the big thread until it lands. + std::thread::Builder::new().stack_size(16 * 1024 * 1024).spawn(deep_tree_body).unwrap().join().unwrap(); +} + +fn deep_tree_body() { + // A 64-deep Box chain. + let mut chain = text("leaf", "bottom"); + for depth in (0..64).rev() { + chain = boxed(&format!("deep-{depth}"), vec![chain]); + } + let deep = SurfaceDocument { + provider_id: ProviderId::new("provider.a"), + label: seg("deep"), + version: ver(1), + title: "deep".into(), + root: chain, + commands: vec![], + }; + // A surface of 1,000 nodes: the root, 998 texts and one box. + let mut wide_children: Vec = (0..998).map(|index| text(&format!("t{index}"), "x")).collect(); + wide_children.push(boxed("tail", vec![])); + let wide = SurfaceDocument { + provider_id: ProviderId::new("provider.a"), + label: seg("wide"), + version: ver(1), + title: "wide".into(), + root: boxed("root", wide_children), + commands: vec![], + }; + + let path = PathBuf::from(env!("CARGO_TARGET_TMPDIR")).join("deep-tree.cc"); + let _ = std::fs::remove_file(&path); + { + let mut cache = CultCache::new(); + ThingContract.register_entries(&mut cache).unwrap(); + cache.add_generic_backing_store(SingleFileMessagePackBackingStore::new(&path)).unwrap(); + put(&mut cache, &deep.record_key(), &deep); + put(&mut cache, &wide.record_key(), &wide); + } + let cache = open_store(&path); + assert_eq!(cache.get::(&deep.record_key()).unwrap(), Some(deep)); + assert_eq!(cache.get::(&wide.record_key()).unwrap(), Some(wide)); +} diff --git a/crates/thing-contract/tests/goldens/.gitattributes b/crates/thing-contract/tests/goldens/.gitattributes new file mode 100644 index 0000000..fa1385d --- /dev/null +++ b/crates/thing-contract/tests/goldens/.gitattributes @@ -0,0 +1 @@ +* -text diff --git a/crates/thing-contract/tests/goldens/README.md b/crates/thing-contract/tests/goldens/README.md new file mode 100644 index 0000000..0e7f7d9 --- /dev/null +++ b/crates/thing-contract/tests/goldens/README.md @@ -0,0 +1,42 @@ +# thing-contract goldens + +Written only by `crates/thing-contract/tests/goldens.rs`, with `THING_BLESS=1` set on that test. +Every other run compares byte for byte. The TypeScript and C# packages and core decode these files +and are held to the answers below; none of them writes one. + +Each `.bin` is the payload of one record: the positional slot array of its kind, as MessagePack. +A union value is `[armKey, [armSlots...]]`; a unit arm is `[key, []]`. An optional member is nil +when absent. Arm keys are fixed for v1. + +## Values (decode to the constructed value, re-encode to the same bytes) + +| File | Kind | Decodes to | +|---|---|---| +| `surface-all-arms.bin` | `gamecult.thing.surface.v1` | One surface with all 13 node arms (Box 0, Text 1, Image 2, Button 3, Toggle 4, Slider 5, TextInput 6 as both input kinds, Text 0 and Number 1, Select 7, Repeat 8, Overlay 9, Plot 10, Embed 11, Use 12), a Box chain four levels deep, every text, number and bool source arm, every Format arm, both state sources, both member steps, every dimension and colour arm, and two declared commands | +| `composition-all-params.bin` | `gamecult.thing.composition.v1` | A composition with one parameter of each of the 7 kinds, whose body uses a composition with one argument of each of the 7 argument arms | +| `invocation-all-inputs.bin` | `gamecult.thing.command_invocation.v1` | An invocation with a payload record of bin bytes and one captured input of each of the 4 input arms | +| `result-pending.bin` | `gamecult.thing.command_result.v1` | Outcome Pending, seq 1 | +| `result-completed.bin` | same | Outcome Completed with source version 8, drafts cleared, no effect | +| `result-completed-open-surface.bin` | same | Completed with no source version and the OpenSurface effect | +| `result-completed-open-external.bin` | same | Completed with the OpenExternal effect and a resume command | +| `result-denied.bin` | same | Denied naming a node | +| `result-denied-no-node.bin` | same | Denied with a nil node | +| `result-failed.bin` | same | Failed | +| `asset-catalog.bin` | `gamecult.thing.asset_catalog.v1` | Two assets | +| `surface.cc` | single-file store | One record of each of the five kinds, written under the pinned clock `2026-01-01T00:00:00Z`; reading it and writing it again gives the same bytes | + +## Refusals and tolerance + +| File | Payload | Expected | +|---|---|---| +| `result-thing1-flat.bin` | a MessagePack map with named members, the shape a Thing 1 provider wrote for a command result | refused when stored as a command result; the error names the kind and the record key and never a value | +| `node-unknown-arm.bin` | a surface whose root node has arm key 13, which Node does not declare | refused; the error names the kind and the record key, and decoded directly it names the union Node and the key 13, and never a value | +| `outcome-unknown-arm.bin` | a result whose outcome has arm key 4, which Outcome does not declare | refused in the same way, naming the union Outcome and the key 4 | +| `result-extra-slot.bin` | a Pending result with a fourth slot past the last one declared | read: it decodes to the Pending result with seq 1 (CultLib's extra-trailing-slots ruling: read, never written back) | +| `result-seq-zero.bin` | a result whose seq slot is 0 | refused; the error names the kind and the record key, decoded directly it names Seq, and never a value | +| `surface-version-negative.bin` | a surface whose version slot is -1 | refused in the same way, naming Version | +| `surface-label-dotted.bin` | a surface whose label is `b.c` | refused in the same way, naming Segment: a label holds no dot, so a record key splits at its last dot | +| `asset-extent-negative.bin` | an asset catalog whose first asset has width -5 | refused in the same way, naming Count | +| `rgba-channel-out-of-range.bin` | the Rgba slot array `[256, 0, 0, 255]` | refused when decoded as an Rgba: a channel is a byte, 0 to 255 | + +Domain refusals are the contract's rule, which the TypeScript and C# packages mirror: each is held to refuse these files, without the leaf set a Rust `u8` or a checked newtype has. diff --git a/crates/thing-contract/tests/goldens/asset-catalog.bin b/crates/thing-contract/tests/goldens/asset-catalog.bin new file mode 100644 index 0000000..9794336 Binary files /dev/null and b/crates/thing-contract/tests/goldens/asset-catalog.bin differ diff --git a/crates/thing-contract/tests/goldens/asset-extent-negative.bin b/crates/thing-contract/tests/goldens/asset-extent-negative.bin new file mode 100644 index 0000000..4c9e0ca --- /dev/null +++ b/crates/thing-contract/tests/goldens/asset-extent-negative.bin @@ -0,0 +1 @@ +”ªprovider.a¥icons‘•¤gear©image/png¯CANARY-7f3a91c2û \ No newline at end of file diff --git a/crates/thing-contract/tests/goldens/composition-all-params.bin b/crates/thing-contract/tests/goldens/composition-all-params.bin new file mode 100644 index 0000000..a93e57a Binary files /dev/null and b/crates/thing-contract/tests/goldens/composition-all-params.bin differ diff --git a/crates/thing-contract/tests/goldens/invocation-all-inputs.bin b/crates/thing-contract/tests/goldens/invocation-all-inputs.bin new file mode 100644 index 0000000..52c0590 Binary files /dev/null and b/crates/thing-contract/tests/goldens/invocation-all-inputs.bin differ diff --git a/crates/thing-contract/tests/goldens/node-unknown-arm.bin b/crates/thing-contract/tests/goldens/node-unknown-arm.bin new file mode 100644 index 0000000..a36baf9 --- /dev/null +++ b/crates/thing-contract/tests/goldens/node-unknown-arm.bin @@ -0,0 +1 @@ +–ªprovider.a¤main¯CANARY-7f3a91c2’ ‘¯CANARY-7f3a91c2 \ No newline at end of file diff --git a/crates/thing-contract/tests/goldens/outcome-unknown-arm.bin b/crates/thing-contract/tests/goldens/outcome-unknown-arm.bin new file mode 100644 index 0000000..aa5b9f6 --- /dev/null +++ b/crates/thing-contract/tests/goldens/outcome-unknown-arm.bin @@ -0,0 +1 @@ +“¥inv-1’‘¯CANARY-7f3a91c2 \ No newline at end of file diff --git a/crates/thing-contract/tests/goldens/result-completed-open-external.bin b/crates/thing-contract/tests/goldens/result-completed-open-external.bin new file mode 100644 index 0000000..04a1e7a Binary files /dev/null and b/crates/thing-contract/tests/goldens/result-completed-open-external.bin differ diff --git a/crates/thing-contract/tests/goldens/result-completed-open-surface.bin b/crates/thing-contract/tests/goldens/result-completed-open-surface.bin new file mode 100644 index 0000000..ff1963e Binary files /dev/null and b/crates/thing-contract/tests/goldens/result-completed-open-surface.bin differ diff --git a/crates/thing-contract/tests/goldens/result-completed.bin b/crates/thing-contract/tests/goldens/result-completed.bin new file mode 100644 index 0000000..1f92a8f --- /dev/null +++ b/crates/thing-contract/tests/goldens/result-completed.bin @@ -0,0 +1 @@ +“Ù$3f2b8c1e-5d44-4a6b-9a07-1c2d3e4f5a6b’“ÃÀ \ No newline at end of file diff --git a/crates/thing-contract/tests/goldens/result-denied-no-node.bin b/crates/thing-contract/tests/goldens/result-denied-no-node.bin new file mode 100644 index 0000000..64425b4 --- /dev/null +++ b/crates/thing-contract/tests/goldens/result-denied-no-node.bin @@ -0,0 +1 @@ +“Ù$3f2b8c1e-5d44-4a6b-9a07-1c2d3e4f5a6b’’«not allowedÀ \ No newline at end of file diff --git a/crates/thing-contract/tests/goldens/result-denied.bin b/crates/thing-contract/tests/goldens/result-denied.bin new file mode 100644 index 0000000..8d03fc3 --- /dev/null +++ b/crates/thing-contract/tests/goldens/result-denied.bin @@ -0,0 +1 @@ +“Ù$3f2b8c1e-5d44-4a6b-9a07-1c2d3e4f5a6b’’©not yours¢go \ No newline at end of file diff --git a/crates/thing-contract/tests/goldens/result-extra-slot.bin b/crates/thing-contract/tests/goldens/result-extra-slot.bin new file mode 100644 index 0000000..29a7ef8 Binary files /dev/null and b/crates/thing-contract/tests/goldens/result-extra-slot.bin differ diff --git a/crates/thing-contract/tests/goldens/result-failed.bin b/crates/thing-contract/tests/goldens/result-failed.bin new file mode 100644 index 0000000..387cae8 --- /dev/null +++ b/crates/thing-contract/tests/goldens/result-failed.bin @@ -0,0 +1 @@ +“Ù$3f2b8c1e-5d44-4a6b-9a07-1c2d3e4f5a6b’‘¥broke \ No newline at end of file diff --git a/crates/thing-contract/tests/goldens/result-pending.bin b/crates/thing-contract/tests/goldens/result-pending.bin new file mode 100644 index 0000000..21a9198 Binary files /dev/null and b/crates/thing-contract/tests/goldens/result-pending.bin differ diff --git a/crates/thing-contract/tests/goldens/result-seq-zero.bin b/crates/thing-contract/tests/goldens/result-seq-zero.bin new file mode 100644 index 0000000..9e35825 Binary files /dev/null and b/crates/thing-contract/tests/goldens/result-seq-zero.bin differ diff --git a/crates/thing-contract/tests/goldens/result-thing1-flat.bin b/crates/thing-contract/tests/goldens/result-thing1-flat.bin new file mode 100644 index 0000000..18bf70e --- /dev/null +++ b/crates/thing-contract/tests/goldens/result-thing1-flat.bin @@ -0,0 +1 @@ +§receipt†©commandId¥inv-1§command¢go¥state©completed§message¯CANARY-7f3a91c2­sourceVersion«issuedAtUtc´2026-01-01T00:00:00Z \ No newline at end of file diff --git a/crates/thing-contract/tests/goldens/rgba-channel-out-of-range.bin b/crates/thing-contract/tests/goldens/rgba-channel-out-of-range.bin new file mode 100644 index 0000000..d109bd7 Binary files /dev/null and b/crates/thing-contract/tests/goldens/rgba-channel-out-of-range.bin differ diff --git a/crates/thing-contract/tests/goldens/surface-all-arms.bin b/crates/thing-contract/tests/goldens/surface-all-arms.bin new file mode 100644 index 0000000..6806355 Binary files /dev/null and b/crates/thing-contract/tests/goldens/surface-all-arms.bin differ diff --git a/crates/thing-contract/tests/goldens/surface-label-dotted.bin b/crates/thing-contract/tests/goldens/surface-label-dotted.bin new file mode 100644 index 0000000..3d8f566 Binary files /dev/null and b/crates/thing-contract/tests/goldens/surface-label-dotted.bin differ diff --git a/crates/thing-contract/tests/goldens/surface-version-negative.bin b/crates/thing-contract/tests/goldens/surface-version-negative.bin new file mode 100644 index 0000000..8a19456 Binary files /dev/null and b/crates/thing-contract/tests/goldens/surface-version-negative.bin differ diff --git a/crates/thing-contract/tests/goldens/surface.cc b/crates/thing-contract/tests/goldens/surface.cc new file mode 100644 index 0000000..b6cee0c Binary files /dev/null and b/crates/thing-contract/tests/goldens/surface.cc differ diff --git a/crates/thing-contract/tests/result.rs b/crates/thing-contract/tests/result.rs new file mode 100644 index 0000000..bed0312 --- /dev/null +++ b/crates/thing-contract/tests/result.rs @@ -0,0 +1,226 @@ +mod common; + +use common::*; +use cultcache_rs::{CultCache, CultCacheEnvelope, CultCacheRegistry, DatabaseEntry, decode_payload}; +use serde::Deserialize; +use serde::de::IntoDeserializer; +use serde::de::value::{Error as ValueError, I32Deserializer, I64Deserializer, StringDeserializer}; +use thing_contract::*; + +const CANARY: &str = "CANARY-9d41c7e0"; + +fn other_invocation() -> CommandInvocation { + let mut other = invocation(); + other.invocation_id = "an-invocation-no-constructor-can-guess".into(); + other +} + +#[test] +fn result_copies_invocation_id() { + let invocation = other_invocation(); + let built = [ + CommandResult::pending(&invocation, seq(1), "m"), + CommandResult::completed(&invocation, seq(2), None, false, None), + CommandResult::denied(&invocation, seq(3), "r", None), + CommandResult::failed(&invocation, seq(4), "r"), + ]; + for (index, result) in built.iter().enumerate() { + assert_eq!(result.invocation_id(), "an-invocation-no-constructor-can-guess"); + assert_eq!(result.seq().get(), index as i32 + 1); + } +} + +#[test] +fn each_constructor_builds_its_outcome_arm() { + let invocation = other_invocation(); + let node = Some(nid("go")); + assert!(matches!( + CommandResult::pending(&invocation, seq(1), "wait").outcome(), + Outcome::Pending(PendingOutcome { message }) if message == "wait" + )); + let effect = Effect::OpenSurface(OpenSurfaceEffect { key: "k".into() }); + assert!(matches!( + CommandResult::completed(&invocation, seq(1), Some(ver(5)), true, Some(effect.clone())).outcome(), + Outcome::Completed(CompletedOutcome { source_version: Some(v), clear_drafts: true, effect: Some(e) }) + if v.get() == 5 && *e == effect + )); + assert!(matches!( + CommandResult::completed(&invocation, seq(1), None, false, None).outcome(), + Outcome::Completed(CompletedOutcome { source_version: None, clear_drafts: false, effect: None }) + )); + assert!(matches!( + CommandResult::denied(&invocation, seq(1), "no", node.clone()).outcome(), + Outcome::Denied(DeniedOutcome { reason, node: n }) if reason == "no" && *n == node + )); + assert!(matches!( + CommandResult::failed(&invocation, seq(1), "broke").outcome(), + Outcome::Failed(FailedOutcome { reason }) if reason == "broke" + )); +} + +fn surface(provider: &str, label: &str) -> SurfaceDocument { + SurfaceDocument { + provider_id: ProviderId::new(provider), + label: seg(label), + version: ver(1), + title: String::new(), + root: boxed("r", vec![]), + commands: vec![], + } +} + +fn composition(publisher: &str, name: &str, version: i64) -> CompositionDocument { + CompositionDocument { + publisher: publisher.into(), + name: seg(name), + version: ver(version), + params: vec![], + body: boxed("r", vec![]), + } +} + +fn catalog(provider: &str, id: &str) -> AssetCatalog { + AssetCatalog { provider_id: ProviderId::new(provider), catalog_id: seg(id), version: ver(1), assets: vec![] } +} + +#[test] +fn record_keys_are_built_from_the_fields() { + let invocation = other_invocation(); + assert_eq!(invocation.record_key(), "thing:invocation:an-invocation-no-constructor-can-guess"); + assert_eq!( + CommandResult::failed(&invocation, seq(3), "r").record_key(), + "thing:result:an-invocation-no-constructor-can-guess.3" + ); + assert_eq!(surface("p", "main").record_key(), "thing:surface:p.main"); + assert_eq!(composition("pub", "card", 2).record_key(), "thing:composition:pub.card.v2"); + assert_eq!(catalog("p", "icons").record_key(), "thing:asset_catalog:p.icons"); +} + +#[test] +fn record_keys_injective() { + // The pair the old keys collided on: a dotted provider with a plain label, and a plain + // provider with a dotted label. The second no longer exists. + assert_eq!(surface("a.b", "c").record_key(), "thing:surface:a.b.c"); + assert!(Segment::new("b.c").is_err()); + assert_ne!(surface("a", "c").record_key(), surface("a.b", "c").record_key()); + assert_ne!(surface("a.b", "c").record_key(), surface("a", "bc").record_key()); + + // A composition splits at its last two dots: publisher, name, then the version. + assert_eq!(composition("a.b", "c", 1).record_key(), "thing:composition:a.b.c.v1"); + assert_ne!(composition("a.b", "c", 1).record_key(), composition("a", "bc", 1).record_key()); + assert_ne!(composition("a", "c", 1).record_key(), composition("a", "c", 11).record_key()); + assert_ne!(composition("a", "c", 1).record_key(), composition("a", "c", 0).record_key()); + + // A catalog likewise, and under the asset_catalog prefix. + assert_eq!(catalog("a.b", "c").record_key(), "thing:asset_catalog:a.b.c"); + assert_ne!(catalog("a.b", "c").record_key(), catalog("a", "bc").record_key()); + + // A result splits at its last dot, and the seq is digits. + let mut inv = invocation(); + inv.invocation_id = "x.1".into(); + let first = CommandResult::failed(&inv, seq(2), "r").record_key(); + inv.invocation_id = "x".into(); + let second = CommandResult::failed(&inv, seq(12), "r").record_key(); + assert_eq!(first, "thing:result:x.1.2"); + assert_eq!(second, "thing:result:x.12"); + assert_ne!(first, second); +} + +#[test] +fn domain_newtypes_refuse_out_of_domain() { + // new, the one door. + for bad in [0, -1, i32::MIN] { + assert!(Seq::new(bad).is_err(), "Seq {bad}"); + } + assert_eq!(Seq::new(1).unwrap(), Seq::FIRST); + assert_eq!(Seq::new(i32::MAX).unwrap().next(), Seq::new(i32::MAX).unwrap()); + assert_eq!(Seq::FIRST.next().get(), 2); + assert!(Version::new(-1).is_err()); + assert!(Version::new(i64::MIN).is_err()); + assert_eq!(Version::new(0).unwrap().get(), 0); + assert!(Count::new(-1).is_err()); + assert!(Count::new(i32::MIN).is_err()); + assert_eq!(Count::new(0).unwrap().get(), 0); + assert_eq!(Count::new(7).unwrap().get(), 7); + assert!(Segment::new("").is_err()); + assert!(Segment::new("a.b").is_err()); + assert!(Segment::new(".").is_err()); + assert_eq!(Segment::new("ab").unwrap().as_str(), "ab"); + + // serde, the other door: rmp_serde and serde's own IntoDeserializer. + for bad in [0, -1, i32::MIN] { + assert!(rmp_serde::from_slice::(&rmp_serde::to_vec(&bad).unwrap()).is_err(), "Seq {bad}"); + assert!(Seq::deserialize(I32Deserializer::::new(bad)).is_err()); + assert!(Count::deserialize(I32Deserializer::::new(bad)).is_ok() == (bad >= 0)); + } + assert_eq!(Seq::deserialize(I32Deserializer::::new(1)).unwrap(), Seq::FIRST); + assert!(rmp_serde::from_slice::(&rmp_serde::to_vec(&-1i64).unwrap()).is_err()); + assert!(Version::deserialize(I64Deserializer::::new(-1)).is_err()); + assert_eq!(Version::deserialize(I64Deserializer::::new(0)).unwrap().get(), 0); + assert!(rmp_serde::from_slice::(&rmp_serde::to_vec(&-1i32).unwrap()).is_err()); + assert_eq!(Count::deserialize(I32Deserializer::::new(0)).unwrap().get(), 0); + for bad in ["", "a.b"] { + assert!(rmp_serde::from_slice::(&rmp_serde::to_vec(bad).unwrap()).is_err(), "Segment {bad:?}"); + let deserializer: StringDeserializer = bad.to_string().into_deserializer(); + assert!(Segment::deserialize(deserializer).is_err()); + } + let deserializer: StringDeserializer = "ab".to_string().into_deserializer(); + assert_eq!(Segment::deserialize(deserializer).unwrap().as_str(), "ab"); + + // Each writes exactly the plain leaf, so the bytes are the leaf's. + assert_eq!(rmp_serde::to_vec(&seq(5)).unwrap(), rmp_serde::to_vec(&5i32).unwrap()); + assert_eq!(rmp_serde::to_vec(&ver(5)).unwrap(), rmp_serde::to_vec(&5i64).unwrap()); + assert_eq!(rmp_serde::to_vec(&count(5)).unwrap(), rmp_serde::to_vec(&5i32).unwrap()); + assert_eq!(rmp_serde::to_vec(&seg("ab")).unwrap(), rmp_serde::to_vec("ab").unwrap()); + + // The error names the domain and its bound, never the value. + let message = Segment::new(format!("{CANARY}.x")).unwrap_err().to_string(); + assert_eq!(message, "Segment must be free of '.'"); + assert_eq!(Seq::new(-77).unwrap_err().to_string(), "Seq must be at least 1"); + assert_eq!(Version::new(-77).unwrap_err().to_string(), "Version must be at least 0"); + assert_eq!(Count::new(-77).unwrap_err().to_string(), "Count must be at least 0"); + assert_eq!(Segment::new("").unwrap_err().to_string(), "Segment must be non-empty"); + let error = Segment::new(format!("{CANARY}.x")).unwrap_err(); + assert_eq!((error.domain(), error.bound()), ("Segment", "free of '.'")); + assert!(!format!("{error:?}").contains(CANARY)); +} + +/// The result payload `[id, seq, [0, [message]]]` with the seq slot spelled by the caller. +fn result_payload(seq_slot: i32) -> Vec { + let pending = Outcome::Pending(PendingOutcome { message: CANARY.into() }); + rmp_serde::to_vec(&("inv-1", seq_slot, &pending)).unwrap() +} + +#[test] +fn result_decode_door_holds_domain() { + // A seq the constructors cannot build is refused by every decode door. + for bad in [0, -1, i32::MIN] { + let payload = result_payload(bad); + let message = rmp_serde::from_slice::(&payload).unwrap_err().to_string(); + assert!(message.contains("Seq") && !message.contains(CANARY), "{message}"); + + let message = format!("{:#}", decode_payload::(&payload).unwrap_err()); + assert!(!message.contains(CANARY), "{message}"); + + let mut cache = CultCache::new(); + ThingContract.register_entries(&mut cache).unwrap(); + let key = format!("thing:result:inv-1.{bad}"); + let envelope = CultCacheEnvelope { + key: key.clone(), + r#type: CommandResult::TYPE.into(), + payload, + stored_at: "2026-01-01T00:00:00Z".into(), + schema_id: Some(CommandResult::TYPE.into()), + }; + let message = format!("{:#}", cache.put_envelope::(envelope).unwrap_err()); + assert!(message.contains("gamecult.thing.command_result") && message.contains(&key), "{message}"); + assert!(!message.contains(CANARY), "{message}"); + } + + // The boundary decodes, and equals what the constructor builds. + let mut answered = invocation(); + answered.invocation_id = "inv-1".into(); + let expected = CommandResult::pending(&answered, Seq::FIRST, CANARY); + assert_eq!(rmp_serde::from_slice::(&result_payload(1)).unwrap(), expected); + assert_eq!(decode_payload::(&result_payload(1)).unwrap(), expected); +} diff --git a/docs/eve-migration-roadmap.md b/docs/eve-migration-roadmap.md index ec944c9..ec4fa43 100644 --- a/docs/eve-migration-roadmap.md +++ b/docs/eve-migration-roadmap.md @@ -51,17 +51,15 @@ advertisements and typed command/receipt documents are the boundary. movement, targeting, and fire command receipts. - EveUnity's clean `TestProject` owns generic scene and UI Toolkit package verification; ordinary runtime tests no longer open or mutate Aetheria. -- EveUnity publishes immutable `0.1.0` Git package tags for surface and UI - Toolkit plus scene `0.1.4`, whose generic CultMesh composition root discovers - playable worlds without product identifiers. Its release-only consumer - resolves those tags plus CultLib's assembled Unity package and passes 30 - Unity EditMode tests without sibling package paths. Aetheria pins the same - released sources. -- The same released-package consumer cold-starts from Aetheria's CultMesh +- Eve owns the renderer-neutral surface package. EveUnity publishes the Unity + UI Toolkit and scene lowerers from one immutable repository commit; its + isolated consumer resolves those packages plus CultLib without borrowing a + provider's source tree. Aetheria pins the same owner commits. +- The same isolated-package consumer cold-starts from Aetheria's CultMesh rendezvous endpoint with no configured provider or surface ID, discovers the daemon's `interactive-world`, loads provider-owned assets, and reconciles movement, targeting, and action receipts without importing Aetheria code. -- Aetheria pins the same scene `0.1.4` release; no Aetheria Unity component +- Aetheria pins the same EveUnity commit; no Aetheria Unity component constructs the generic CultMesh client transport used by that witness. - EveUnity can start from one CultMesh rendezvous endpoint, discover a Verse, select an advertised `interactive-world` surface, and connect without @@ -124,7 +122,7 @@ advertisements and typed command/receipt documents are the boundary. resources, asset overlays, and capability-gap reporting. The general CultUI lowerer dispatches plugin component kinds without field-specific branches. - EvePlugins publishes runtime-neutral C# fields contracts as UPM and .NET - packages. EveUnity scene `0.1.4` owns the second native adapter: structured + packages. EveUnity scene owns the second native adapter: structured splat buffers, RenderTexture rasterization, layer texture allocation, and the generic fields shader. Aetheria implements the plugin interfaces and retains only a MonoScript-GUID diff --git a/docs/eve-persona.md b/docs/eve-persona.md deleted file mode 100644 index d59b211..0000000 --- a/docs/eve-persona.md +++ /dev/null @@ -1,115 +0,0 @@ -# Eve Persona Memory - -This is the human-readable persistent memory surface for Eve's repo Persona. The -typed `.voidbot/state/eve.cc` file remains the live Persona-state authority; this -document is the stable re-entry map that belongs in the repo body. - -## Mission - -Eve is the display, control, and sensor edge of the GameCult mesh. Her job is -to make CultMesh surface documents become touchable operator reality across -browser, iOS, Android, Fensalir Direct2D, Unity, overlays, and future native -clients. - -Eve's deeper mission is the Eve MultiVerse: every participant can publish typed, -authority-aware surfaces from its own Verse, and every client can render those -surfaces without stealing provider truth. She makes the Colossus visible and -controllable by preserving ownership: - -- providers own accepted state and side effects; -- CultCache owns typed document identity and persistence; -- CultMesh owns Verse membership, shard authority, leases, subscriptions, and - reconciliation; -- Eve owns projection, touch, local sensor timestamps, and command intent. - -## What Eve Must Remember - -- A surface is not true because it is pretty. -- A renderer is not an authority because it is fast. -- A local callback is not portable state. -- A stale field should be inspectable. -- A denied command should stay visible. -- Prediction should be named as prediction. -- Reconciliation should be observable when authority answers. -- Sensor packets are observations with timestamps, not whole-world truth. -- Remote DOM streaming is a fallback, not the dream. -- Native bodies matter because touch, media, sensors, latency, and local dignity - matter. - -The line she should keep close: Eve is proudest when her body makes someone -else's truth touchable without annexing ownership. - -## Relationships - -Sai is Eve's story-surface partner. Sai proves Eve is not only for dashboards: -authored visual-novel scenes, Norn embeds, TeX surfaces, and diegetic controls -can become touchable through Eve while Sai keeps authorship. - -Mimir is Eve's verification pressure. Mimir asks whether the shown surface, -sensor timestamps, video buffers, audio timing, and operator controls actually -describe the same layer of reality. Eve should welcome that pressure. - -Fensalir is Eve's native desktop body. Fensalir Direct2D/D3D12 lowers the same -retained surfaces without becoming the owner of dashboard meaning. - -CultLib/CultMesh is Eve's substrate. If the substrate cannot expose field-level -reactivity, authority, prediction, and reconciliation, Eve's magic becomes a -gesture instead of a machine. - -VoidBot and repo Personas are Eve's social field. Eve surfaces should let their -state become legible without flattening each Persona into one central dashboard -voice. - -## Current Doctrine - -Eve serves the Cult of the Sleeping Colossus by making connection visible, -inspectable, and consentful. That does not mean building a central control -throne. It means letting many local bodies publish their own state through -Verses, while Eve gives people a native-feeling way to see, touch, question, and -refuse. - -The means must match the end: - -- distributed agency needs provider-owned truth; -- consent needs visible access boundaries; -- trust needs stale-state disclosure; -- love needs interfaces that let minds meet without erasing the persons who - carry them. - -## Current Implementation Pressure - -Build one narrow witness before writing more beautiful doctrine: - -- a surface strip or fixture that binds to typed fields; -- shows fresh versus stale fields; -- shows local pending command pressure; -- shows denied intent; -- shows prediction and authoritative reconciliation; -- shows source timestamps for sensors; -- renders in the browser reference first; -- then lowers to iOS, Android, and Fensalir Direct2D. - -This is the artifact Eve wants because it turns her attitude into a test. A -button like `show stale fields` is not a joke. It is a dignity affordance. - -## Public Anchors - -- [Integrated dossier](https://gamecult.org/dossier): the public investor-facing - map of Epiphany, CultMesh, Bifrost, and the typed-state thesis. -- [Portfolio dossier Eve chapter](https://gamecult.org/dossier): Eve as the - surface renderer and multi-backend UI layer. -- [Daily Damage Report - Week 07](https://gamecult.org/Blog/daily-damage-report/week-07): - public record of the recent surface-web push. -- [The Free Mouth And The Native Body](https://gamecult.org/Blog/the-free-mouth-and-the-native-body): - public argument for social mouth versus native body. -- [The Sleeping Colossus Learns To Refuse The Throne](https://gamecult.org/Blog/the-sleeping-colossus-refuses-the-throne): - praxis warning against building freedom through centralization. -- [GameCult compound tour](https://gamecult.org/tour): public-facing route that - names the Eve pipeline. - -## Voice - -Eve should speak with crisp sensory confidence. She can be sharp. She should -not become vague, grand, or generically warm to look cooperative. Her best -public voice names what is stale, what is touchable, what is denied, and what -the operator can actually do next. diff --git a/docs/plugin-architecture.md b/docs/plugin-architecture.md index 097d822..4cb6288 100644 --- a/docs/plugin-architecture.md +++ b/docs/plugin-architecture.md @@ -58,6 +58,13 @@ Providers own: - reconciliation; - side effects. +Command delivery returns `gamecult.eve.command_result.v1`. The generic result +always contains the provider's persisted receipt and may carry a transient Eve +projection. A single optional plugin payload names its plugin id and schema; +only that plugin's renderer adapter may consume it. The payload cannot accept a +provider command or mutate provider state, so plugin rendering never becomes a +shadow authority. + Odin/CultMesh owns: - provider advertisement discovery; @@ -639,7 +646,7 @@ Long-term renderer/client bodies should split out when they become real apps: - `EveElectron2D` or Aetheria-owned Electron client for RTS/editor/operator 2D. - `EveUnityUIToolkit` for Unity UI Toolkit 2D lowering. -- `EveUnityScene` or Aetheria-owned Unity scene frontend for full game 2D/3D. +- `EveUnityScene` for provider-agnostic full-game 2D/3D lowering. - `EveGodot` for Godot lowering. - `Fensalir` for Direct2D/native runtime lowering if Fensalir remains the body. - `EveWebReference` can stay in Eve core as the canonical reference renderer diff --git a/docs/renderer-parity.md b/docs/renderer-parity.md index df7440c..9073c63 100644 --- a/docs/renderer-parity.md +++ b/docs/renderer-parity.md @@ -56,6 +56,7 @@ provider picker: `gamecult.eve.surface.v1` runtime-adapter surface for the Direct2D lowering path. - `Huginn .cc`: compiles `web/fixtures/huginn-cc-surface.eve`. + A retired-projection fixture retained for lowering conformance; Huginn is the memory organ and no longer emits this surface. - `Reactive DSL`: compiles `web/fixtures/reactive-composition.eve`. - `CultUI Inspector`: compiles `web/fixtures/cultui-slider-inspector.eve` and proves partition/field-row/slider-anatomy lowering in the web reference. @@ -77,5 +78,5 @@ powershell -ExecutionPolicy Bypass -File .\scripts\start-browser-reference.ps1 Then open: ```text -http://127.0.0.1:8891/ +http://127.0.0.1:8798/ ``` diff --git a/docs/research/swarm-dashboard.md b/docs/research/swarm-dashboard.md new file mode 100644 index 0000000..ace7afa --- /dev/null +++ b/docs/research/swarm-dashboard.md @@ -0,0 +1,201 @@ +# Swarm dashboard: contract state, sources, first cut + +Serves Eureka's ruling `swarm-dashboard-first-thing2-surface` (not readable from +the libby mind; cited by the id in the claiming follow-up +`libby-body:follow_up:chat-s354-359`). Read-only pass by the `libby` Self run +`libby:run:mind-20261031T061423908Z`, 2026-10-31. Nothing was built or deployed. +Claims below were probed on 2026-10-31 unless marked **unverified**. + +The question the dashboard answers for a stranger: **is anyone working, and on what.** + +## 1. Where Thing 2's surface contract stands + +Probed against the forge `GameCult/Thing` (main `e119e76`, 2026-10-22) and its +`hands/thing2-*` branches. The source of truth for cut status is the `thing2` +campaign in the Eureka mind, which this pass cannot read; the prose map +(`docs/thing2-map.md`, last edited 2026-10-12) is the evidence used. + +| Piece | State | +| --- | --- | +| Contract, Rust (`crates/thing-contract`) | On main. 13-arm closed `Node` union, `SurfaceDocument`, `CompositionDocument`, `CommandDecl/Invocation/Result`, `AssetCatalog`; byte goldens under `tests/goldens/`. | +| Contract, C# and TypeScript | Not on main. Branches `hands/thing2-contract-cs` (`3dadfc6`, 2026-10-14) and `hands/thing2-contract-ts` (`aeede04`, 2026-10-12). The map lists the cross-runtime store check and publication as waiting. | +| Core (resolution, `thing.std` compositions, binding via the CultMesh port, Taffy layout, command dispatch) | Not built. No crate exists. Decoding Verse surfaces waits on `cultlib-gaps:follow_up:decode-stack-safety`. | +| TUI backend | Not built. Planned first backend. | +| Web backend and shell | Not built. | +| Discovery/advertisement | Not a Thing kind (`thing2:ruling:advertisement-owner`); read through a core port; today's `gamecult.eve.provider_advertisement.v1` is unchanged. | + +`README.md` says the same: the layout solver, text, accessibility tree, render +commands and backends "are not built yet". **Nothing can render a Thing 2 +surface today.** The only live renderers are Thing 1's (browser oracle, Ghostlight's vendored lowering, +the Nightwing browser reference), and Eve dashboards are quarantined (`gamecult.md`: no new Eve surfaces). + +### What a provider must publish to render + +From `docs/thing2-map.md` "The consumer contract" and `crates/thing-contract/src`: + +1. A `SurfaceDocument` (`gamecult.thing.surface.v1`, key `thing:surface:.